1// 2// Copyright (C) 2012 The Android Open Source Project 3// 4// Licensed under the Apache License, Version 2.0 (the "License"); 5// you may not use this file except in compliance with the License. 6// You may obtain a copy of the License at 7// 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// See the License for the specific language governing permissions and 14// limitations under the License. 15// 16 17#include "shill/key_value_store.h" 18 19#include <gtest/gtest.h> 20 21using std::map; 22using std::string; 23using std::vector; 24using testing::Test; 25 26namespace shill { 27 28class KeyValueStoreTest : public Test { 29 public: 30 KeyValueStoreTest() {} 31 32 protected: 33 KeyValueStore store_; 34}; 35 36TEST_F(KeyValueStoreTest, Any) { 37 const string kKey("foo"); 38 const string kValue("baz"); 39 EXPECT_FALSE(store_.Contains(kKey)); 40 store_.Set(kKey, brillo::Any(kValue)); 41 EXPECT_TRUE(store_.Contains(kKey)); 42 EXPECT_EQ(kValue, store_.Get(kKey).Get<string>()); 43 store_.Remove(kKey); 44 EXPECT_FALSE(store_.Contains(kKey)); 45} 46 47TEST_F(KeyValueStoreTest, Bool) { 48 const string kKey("foo"); 49 const bool kDefaultValue = true; 50 const bool kValue = false; 51 EXPECT_FALSE(store_.ContainsBool(kKey)); 52 EXPECT_EQ(kDefaultValue, store_.LookupBool(kKey, kDefaultValue)); 53 store_.SetBool(kKey, kValue); 54 EXPECT_TRUE(store_.ContainsBool(kKey)); 55 // TODO(shenhan): investigate if a newer version of gtest handles EXPECT_EQ 56 // for bools in a manner that gcc 4.7 is happy with. (Improper conversion from 57 // "false" to "NULL"). 58 EXPECT_EQ(static_cast<int>(kValue), 59 static_cast<int>(store_.LookupBool(kKey, kDefaultValue))); 60 EXPECT_EQ(static_cast<int>(kValue), 61 static_cast<int>(store_.GetBool(kKey))); 62} 63 64TEST_F(KeyValueStoreTest, ByteArrays) { 65 const string kKey("foo"); 66 const vector<vector<uint8_t>> kValue{ {1, 2, 3 } }; 67 EXPECT_FALSE(store_.ContainsByteArrays(kKey)); 68 store_.SetByteArrays(kKey, kValue); 69 EXPECT_TRUE(store_.ContainsByteArrays(kKey)); 70 EXPECT_EQ(kValue, store_.GetByteArrays(kKey)); 71 store_.RemoveByteArrays(kKey); 72 EXPECT_FALSE(store_.ContainsByteArrays(kKey)); 73} 74 75TEST_F(KeyValueStoreTest, Int) { 76 const string kKey("foo"); 77 const int kValue = 456; 78 EXPECT_FALSE(store_.ContainsInt(kKey)); 79 const int kDefaultValue = 789; 80 EXPECT_EQ(kDefaultValue, store_.LookupInt(kKey, kDefaultValue)); 81 store_.SetInt(kKey, kValue); 82 EXPECT_TRUE(store_.ContainsInt(kKey)); 83 EXPECT_EQ(kValue, store_.GetInt(kKey)); 84 EXPECT_EQ(kValue, store_.LookupInt(kKey, kDefaultValue)); 85 store_.RemoveInt(kKey); 86 EXPECT_FALSE(store_.ContainsInt(kKey)); 87} 88 89TEST_F(KeyValueStoreTest, Int16) { 90 const string kKey("foo"); 91 const int16_t kValue = 123; 92 EXPECT_FALSE(store_.ContainsInt16(kKey)); 93 store_.SetInt16(kKey, kValue); 94 EXPECT_TRUE(store_.ContainsInt16(kKey)); 95 EXPECT_EQ(kValue, store_.GetInt16(kKey)); 96 store_.RemoveInt16(kKey); 97 EXPECT_FALSE(store_.ContainsInt16(kKey)); 98} 99 100TEST_F(KeyValueStoreTest, KeyValueStore) { 101 const string kSubKey("foo"); 102 const map<string, string> kSubValue{ { "bar0", "baz0" }, { "bar1", "baz1" } }; 103 KeyValueStore value; 104 value.SetStringmap(kSubKey, kSubValue); 105 const string kKey("foo"); 106 EXPECT_FALSE(store_.ContainsKeyValueStore(kKey)); 107 store_.SetKeyValueStore(kKey, value); 108 EXPECT_TRUE(store_.ContainsKeyValueStore(kKey)); 109 EXPECT_EQ(value, store_.GetKeyValueStore(kKey)); 110 store_.RemoveKeyValueStore(kKey); 111 EXPECT_FALSE(store_.ContainsKeyValueStore(kKey)); 112} 113 114TEST_F(KeyValueStoreTest, RpcIdentifier) { 115 const string kKey("foo"); 116 const string kValue("baz"); 117 EXPECT_FALSE(store_.ContainsRpcIdentifier(kKey)); 118 store_.SetRpcIdentifier(kKey, kValue); 119 EXPECT_TRUE(store_.ContainsRpcIdentifier(kKey)); 120 EXPECT_EQ(kValue, store_.GetRpcIdentifier(kKey)); 121 store_.RemoveRpcIdentifier(kKey); 122 EXPECT_FALSE(store_.ContainsRpcIdentifier(kKey)); 123} 124 125TEST_F(KeyValueStoreTest, RpcIdentifiers) { 126 const string kKey("foo"); 127 const vector<string> kValue{ "baz0", "baz1", "baz2" }; 128 EXPECT_FALSE(store_.ContainsRpcIdentifiers(kKey)); 129 store_.SetRpcIdentifiers(kKey, kValue); 130 EXPECT_TRUE(store_.ContainsRpcIdentifiers(kKey)); 131 EXPECT_EQ(kValue, store_.GetRpcIdentifiers(kKey)); 132 store_.Remove(kKey); 133 EXPECT_FALSE(store_.ContainsRpcIdentifiers(kKey)); 134} 135 136TEST_F(KeyValueStoreTest, String) { 137 const string kKey("foo"); 138 const string kDefaultValue("bar"); 139 const string kValue("baz"); 140 EXPECT_FALSE(store_.ContainsString(kKey)); 141 EXPECT_EQ(kDefaultValue, store_.LookupString(kKey, kDefaultValue)); 142 store_.SetString(kKey, kValue); 143 EXPECT_TRUE(store_.ContainsString(kKey)); 144 EXPECT_EQ(kValue, store_.LookupString(kKey, kDefaultValue)); 145 EXPECT_EQ(kValue, store_.GetString(kKey)); 146 store_.RemoveString(kKey); 147 EXPECT_FALSE(store_.ContainsString(kKey)); 148 EXPECT_EQ(kDefaultValue, store_.LookupString(kKey, kDefaultValue)); 149} 150 151TEST_F(KeyValueStoreTest, Stringmap) { 152 const string kKey("foo"); 153 const map<string, string> kValue{ { "bar0", "baz0" }, { "bar1", "baz1" } }; 154 EXPECT_FALSE(store_.ContainsStringmap(kKey)); 155 store_.SetStringmap(kKey, kValue); 156 EXPECT_TRUE(store_.ContainsStringmap(kKey)); 157 EXPECT_EQ(kValue, store_.GetStringmap(kKey)); 158 store_.RemoveStringmap(kKey); 159 EXPECT_FALSE(store_.ContainsStringmap(kKey)); 160} 161 162TEST_F(KeyValueStoreTest, Strings) { 163 const string kKey("foo"); 164 const vector<string> kValue{ "baz0", "baz1", "baz2" }; 165 EXPECT_FALSE(store_.ContainsStrings(kKey)); 166 store_.SetStrings(kKey, kValue); 167 EXPECT_TRUE(store_.ContainsStrings(kKey)); 168 EXPECT_EQ(kValue, store_.GetStrings(kKey)); 169 store_.RemoveStrings(kKey); 170 EXPECT_FALSE(store_.ContainsStrings(kKey)); 171} 172 173TEST_F(KeyValueStoreTest, Uint) { 174 const string kKey("foo"); 175 const uint32_t kValue = 456; 176 EXPECT_FALSE(store_.ContainsUint(kKey)); 177 store_.SetUint(kKey, kValue); 178 EXPECT_TRUE(store_.ContainsUint(kKey)); 179 EXPECT_EQ(kValue, store_.GetUint(kKey)); 180} 181 182TEST_F(KeyValueStoreTest, Uint16) { 183 const string kKey("foo"); 184 const uint16_t kValue = 456; 185 EXPECT_FALSE(store_.ContainsUint16(kKey)); 186 store_.SetUint16(kKey, kValue); 187 EXPECT_TRUE(store_.ContainsUint16(kKey)); 188 EXPECT_EQ(kValue, store_.GetUint16(kKey)); 189} 190 191TEST_F(KeyValueStoreTest, Uint8) { 192 const string kKey("foo"); 193 const uint8_t kValue = 123; 194 EXPECT_FALSE(store_.ContainsUint8(kKey)); 195 store_.SetUint8(kKey, kValue); 196 EXPECT_TRUE(store_.ContainsUint8(kKey)); 197 EXPECT_EQ(kValue, store_.GetUint8(kKey)); 198 store_.RemoveUint8(kKey); 199 EXPECT_FALSE(store_.ContainsUint8(kKey)); 200} 201 202TEST_F(KeyValueStoreTest, Uint8s) { 203 const string kKey("foo"); 204 const vector<uint8_t> kValue{ 1, 2, 3 }; 205 EXPECT_FALSE(store_.ContainsUint8s(kKey)); 206 store_.SetUint8s(kKey, kValue); 207 EXPECT_TRUE(store_.ContainsUint8s(kKey)); 208 EXPECT_EQ(kValue, store_.GetUint8s(kKey)); 209 store_.RemoveUint8s(kKey); 210 EXPECT_FALSE(store_.ContainsUint8s(kKey)); 211} 212 213TEST_F(KeyValueStoreTest, Uint32s) { 214 const string kKey("foo"); 215 const vector<uint32_t> kValue{ 1, 2, 3 }; 216 EXPECT_FALSE(store_.ContainsUint32s(kKey)); 217 store_.SetUint32s(kKey, kValue); 218 EXPECT_TRUE(store_.ContainsUint32s(kKey)); 219 EXPECT_EQ(kValue, store_.GetUint32s(kKey)); 220 store_.RemoveUint32s(kKey); 221 EXPECT_FALSE(store_.ContainsUint32s(kKey)); 222} 223 224TEST_F(KeyValueStoreTest, DoubleRemove) { 225 const string kKey("foo"); 226 // Make sure we don't get an exception/infinite loop if we do a 227 // "Remove()" when the key does not exist. 228 store_.RemoveInt(kKey); 229 store_.RemoveInt(kKey); 230 store_.RemoveString(kKey); 231 store_.RemoveString(kKey); 232} 233 234TEST_F(KeyValueStoreTest, Clear) { 235 EXPECT_TRUE(store_.IsEmpty()); 236 const string kBoolKey("foo"); 237 const bool kBoolValue = true; 238 store_.SetBool(kBoolKey, kBoolValue); 239 const string kByteArraysKey("bytearrays"); 240 const vector<vector<uint8_t>> kByteArraysValue{ {1, 2} }; 241 store_.SetByteArrays(kByteArraysKey, kByteArraysValue); 242 const string kIntKey("bar"); 243 const int kIntValue = 123; 244 store_.SetInt(kIntKey, kIntValue); 245 const string kInt16Key("int16"); 246 const int16_t kInt16Value = 123; 247 store_.SetInt16(kInt16Key, kInt16Value); 248 const string kKeyValueStoreKey("bear"); 249 const KeyValueStore kKeyValueStoreValue; 250 store_.SetKeyValueStore(kKeyValueStoreKey, kKeyValueStoreValue); 251 const string kRpcIdentifierKey("rpcid"); 252 const string kRpcIdentifierValue("rpc_identifier"); 253 store_.SetRpcIdentifier(kRpcIdentifierKey, kRpcIdentifierValue); 254 const string kStringKey("baz"); 255 const string kStringValue("string"); 256 store_.SetString(kStringKey, kStringValue); 257 const string kStringmapKey("stringMapKey"); 258 const map<string, string> kStringmapValue; 259 store_.SetStringmap(kStringmapKey, kStringmapValue); 260 const string kStringsKey("stringsKey"); 261 const vector<string> kStringsValue; 262 store_.SetStrings(kStringsKey, kStringsValue); 263 const string kUintKey("bun"); 264 const uint32_t kUintValue = 456; 265 store_.SetUint(kUintKey, kUintValue); 266 const string kUint16Key("uint16"); 267 const uint16_t kUint16Value = 123; 268 store_.SetUint16(kUint16Key, kUint16Value); 269 const string kUint8sKey("uint8s"); 270 const vector<uint8_t> kUint8sValue{ 1, 2, 3 }; 271 store_.SetUint8s(kUint8sKey, kUint8sValue); 272 const string kUint32sKey("uint32s"); 273 const vector<uint32_t> kUint32sValue{ 1, 2, 3 }; 274 store_.SetUint32s(kUint32sKey, kUint32sValue); 275 276 EXPECT_TRUE(store_.ContainsBool(kBoolKey)); 277 EXPECT_TRUE(store_.ContainsByteArrays(kByteArraysKey)); 278 EXPECT_TRUE(store_.ContainsInt(kIntKey)); 279 EXPECT_TRUE(store_.ContainsInt16(kInt16Key)); 280 EXPECT_TRUE(store_.ContainsKeyValueStore(kKeyValueStoreKey)); 281 EXPECT_TRUE(store_.ContainsRpcIdentifier(kRpcIdentifierKey)); 282 EXPECT_TRUE(store_.ContainsString(kStringKey)); 283 EXPECT_TRUE(store_.ContainsStringmap(kStringmapKey)); 284 EXPECT_TRUE(store_.ContainsStrings(kStringsKey)); 285 EXPECT_TRUE(store_.ContainsUint(kUintKey)); 286 EXPECT_TRUE(store_.ContainsUint16(kUint16Key)); 287 EXPECT_TRUE(store_.ContainsUint8s(kUint8sKey)); 288 EXPECT_TRUE(store_.ContainsUint32s(kUint32sKey)); 289 EXPECT_FALSE(store_.IsEmpty()); 290 store_.Clear(); 291 EXPECT_TRUE(store_.IsEmpty()); 292 EXPECT_FALSE(store_.ContainsBool(kBoolKey)); 293 EXPECT_FALSE(store_.ContainsByteArrays(kByteArraysKey)); 294 EXPECT_FALSE(store_.ContainsInt(kIntKey)); 295 EXPECT_FALSE(store_.ContainsInt16(kInt16Key)); 296 EXPECT_FALSE(store_.ContainsInt(kKeyValueStoreKey)); 297 EXPECT_FALSE(store_.ContainsRpcIdentifier(kRpcIdentifierKey)); 298 EXPECT_FALSE(store_.ContainsString(kStringKey)); 299 EXPECT_FALSE(store_.ContainsStringmap(kStringmapKey)); 300 EXPECT_FALSE(store_.ContainsStrings(kStringsKey)); 301 EXPECT_FALSE(store_.ContainsUint(kUintKey)); 302 EXPECT_FALSE(store_.ContainsUint16(kUint16Key)); 303 EXPECT_FALSE(store_.ContainsUint8s(kUint8sKey)); 304 EXPECT_FALSE(store_.ContainsUint32s(kUint32sKey)); 305} 306 307TEST_F(KeyValueStoreTest, Equals) { 308 KeyValueStore first, second; 309 310 first.SetBool("boolKey", true); 311 EXPECT_NE(first, second); 312 313 first.Clear(); 314 second.Clear(); 315 second.SetBool("boolKey", true); 316 EXPECT_NE(first, second); 317 318 first.Clear(); 319 second.Clear(); 320 first.SetBool("boolKey", true); 321 second.SetBool("boolOtherKey", true); 322 EXPECT_NE(first, second); 323 324 first.Clear(); 325 second.Clear(); 326 first.SetBool("boolKey", true); 327 second.SetBool("boolKey", false); 328 EXPECT_NE(first, second); 329 330 const vector<vector<uint8_t>> kByteArrays1{ {1, 2} }; 331 const vector<vector<uint8_t>> kByteArrays2{ {3, 4} }; 332 333 first.Clear(); 334 second.Clear(); 335 first.SetByteArrays("byteArraysKey", kByteArrays1); 336 second.SetByteArrays("byteArraysOtherKey", kByteArrays1); 337 EXPECT_NE(first, second); 338 339 first.Clear(); 340 second.Clear(); 341 first.SetByteArrays("byteArraysKey", kByteArrays1); 342 second.SetByteArrays("byteArraysOtherKey", kByteArrays2); 343 EXPECT_NE(first, second); 344 345 first.Clear(); 346 second.Clear(); 347 first.SetInt("intKey", 123); 348 second.SetInt("intOtherKey", 123); 349 EXPECT_NE(first, second); 350 351 first.Clear(); 352 second.Clear(); 353 first.SetInt("intKey", 123); 354 second.SetInt("intKey", 456); 355 EXPECT_NE(first, second); 356 357 first.Clear(); 358 second.Clear(); 359 first.SetInt16("int16Key", 123); 360 second.SetInt16("int16OtherKey", 123); 361 EXPECT_NE(first, second); 362 363 first.Clear(); 364 second.Clear(); 365 first.SetInt16("int16Key", 123); 366 second.SetInt16("int16Key", 456); 367 EXPECT_NE(first, second); 368 369 KeyValueStore key_value0; 370 key_value0.SetInt("intKey", 123); 371 KeyValueStore key_value1; 372 key_value1.SetInt("intOtherKey", 123); 373 374 first.Clear(); 375 second.Clear(); 376 first.SetKeyValueStore("keyValueKey", key_value0); 377 second.SetKeyValueStore("keyValueKey", key_value1); 378 EXPECT_NE(first, second); 379 380 first.Clear(); 381 second.Clear(); 382 first.SetKeyValueStore("keyValueKey", key_value0); 383 second.SetKeyValueStore("keyValueOtherKey", key_value0); 384 EXPECT_NE(first, second); 385 386 first.Clear(); 387 second.Clear(); 388 first.SetRpcIdentifier("rpcIdentifierKey", "rpcIdentifier"); 389 second.SetRpcIdentifier("rpcIdentifierOtherKey", "rpcIdentifier"); 390 EXPECT_NE(first, second); 391 392 first.Clear(); 393 second.Clear(); 394 first.SetRpcIdentifier("rpcIdentifierKey", "rpcIdentifier"); 395 second.SetRpcIdentifier("rpcIdentifierKey", "otherRpcIdentifier"); 396 EXPECT_NE(first, second); 397 398 first.Clear(); 399 second.Clear(); 400 first.SetString("stringKey", "string"); 401 second.SetString("stringOtherKey", "string"); 402 EXPECT_NE(first, second); 403 404 first.Clear(); 405 second.Clear(); 406 first.SetString("stringKey", "string"); 407 second.SetString("stringKey", "otherString"); 408 EXPECT_NE(first, second); 409 410 411 const map<string, string> kStringmap1{ { "key", "value" } }; 412 const map<string, string> kStringmap2{ { "otherKey", "value" } }; 413 const map<string, string> kStringmap3{ { "key", "otherValue" } }; 414 415 first.Clear(); 416 second.Clear(); 417 first.SetStringmap("stringmapKey", kStringmap1); 418 second.SetStringmap("stringmapOtherKey", kStringmap1); 419 EXPECT_NE(first, second); 420 421 first.Clear(); 422 second.Clear(); 423 first.SetStringmap("stringmapKey", kStringmap1); 424 second.SetStringmap("stringmapKey", kStringmap2); 425 EXPECT_NE(first, second); 426 427 first.Clear(); 428 second.Clear(); 429 first.SetStringmap("stringmapKey", kStringmap1); 430 second.SetStringmap("stringmapKey", kStringmap3); 431 EXPECT_NE(first, second); 432 433 const vector<string> kStrings1{ "value" }; 434 const vector<string> kStrings2{ "otherValue" }; 435 436 first.Clear(); 437 second.Clear(); 438 first.SetStrings("stringsKey", kStrings1); 439 second.SetStrings("stringsOtherKey", kStrings1); 440 EXPECT_NE(first, second); 441 442 first.Clear(); 443 second.Clear(); 444 first.SetStrings("stringsKey", kStrings1); 445 second.SetStrings("stringsKey", kStrings2); 446 EXPECT_NE(first, second); 447 448 first.Clear(); 449 second.Clear(); 450 first.SetUint("uintKey", 1); 451 second.SetUint("uintOtherKey", 1); 452 EXPECT_NE(first, second); 453 454 first.Clear(); 455 second.Clear(); 456 first.SetUint("uintKey", 1); 457 second.SetUint("uintKey", 2); 458 EXPECT_NE(first, second); 459 460 first.Clear(); 461 second.Clear(); 462 first.SetUint16("uint16Key", 1); 463 second.SetUint16("uint16OtherKey", 1); 464 EXPECT_NE(first, second); 465 466 first.Clear(); 467 second.Clear(); 468 first.SetUint16("uint16Key", 1); 469 second.SetUint16("uint16Key", 2); 470 EXPECT_NE(first, second); 471 472 const vector<uint8_t> kUint8s1{ 1 }; 473 const vector<uint8_t> kUint8s2{ 2 }; 474 475 first.Clear(); 476 second.Clear(); 477 first.SetUint8s("uint8sKey", kUint8s1); 478 second.SetUint8s("uint8sOtherKey", kUint8s1); 479 EXPECT_NE(first, second); 480 481 first.Clear(); 482 second.Clear(); 483 first.SetUint8s("uint8sKey", kUint8s1); 484 second.SetUint8s("uint8sKey", kUint8s2); 485 EXPECT_NE(first, second); 486 487 const vector<uint32_t> kUint32s1{ 1 }; 488 const vector<uint32_t> kUint32s2{ 2 }; 489 490 first.Clear(); 491 second.Clear(); 492 first.SetUint32s("uint32sKey", kUint32s1); 493 second.SetUint32s("uint32sOtherKey", kUint32s1); 494 EXPECT_NE(first, second); 495 496 first.Clear(); 497 second.Clear(); 498 first.SetUint32s("uint32sKey", kUint32s1); 499 second.SetUint32s("uint32sKey", kUint32s2); 500 EXPECT_NE(first, second); 501 502 first.Clear(); 503 second.Clear(); 504 first.SetBool("boolKey", true); 505 first.SetByteArrays("byteArraysKey", kByteArrays1); 506 first.SetInt("intKey", 123); 507 first.SetInt("int16Key", 123); 508 first.SetRpcIdentifier("rpcIdentifierKey", "rpcid"); 509 first.SetString("stringKey", "value"); 510 first.SetStringmap("stringmapKey", kStringmap1); 511 first.SetStrings("stringsKey", kStrings1); 512 first.SetUint("uintKey", 1); 513 first.SetUint16("uint16Key", 1); 514 first.SetUint8s("uint8sKey", kUint8s1); 515 first.SetUint32s("uint32sKey", kUint32s1); 516 second.SetBool("boolKey", true); 517 second.SetByteArrays("byteArraysKey", kByteArrays1); 518 second.SetInt("intKey", 123); 519 second.SetInt("int16Key", 123); 520 second.SetRpcIdentifier("rpcIdentifierKey", "rpcid"); 521 second.SetString("stringKey", "value"); 522 second.SetStringmap("stringmapKey", kStringmap1); 523 second.SetStrings("stringsKey", kStrings1); 524 second.SetUint("uintKey", 1); 525 second.SetUint16("uint16Key", 1); 526 second.SetUint8s("uint8sKey", kUint8s1); 527 second.SetUint32s("uint32sKey", kUint32s1); 528 EXPECT_EQ(first, second); 529} 530 531TEST_F(KeyValueStoreTest, CopyFrom) { 532 KeyValueStore donor; 533 const string kBoolKey("foo"); 534 const bool kBoolValue = true; 535 donor.SetBool(kBoolKey, kBoolValue); 536 const string kByteArraysKey("bytearrays"); 537 const vector<vector<uint8_t>> kByteArraysValue{ {1} }; 538 donor.SetByteArrays(kByteArraysKey, kByteArraysValue); 539 const string kIntKey("bar"); 540 const int kIntValue = 123; 541 donor.SetInt(kIntKey, kIntValue); 542 const string kInt16Key("int16"); 543 const int16_t kInt16Value = 123; 544 donor.SetInt16(kInt16Key, kInt16Value); 545 const string kKeyValueStoreKey("bear"); 546 KeyValueStore keyValueStoreValue; 547 keyValueStoreValue.SetInt(kIntKey, kIntValue); 548 donor.SetKeyValueStore(kKeyValueStoreKey, keyValueStoreValue); 549 const string kRpcIdentifierKey("rpcidentifier"); 550 const string kRpcIdentifierValue("rpcid"); 551 donor.SetRpcIdentifier(kRpcIdentifierKey, kRpcIdentifierValue); 552 const string kStringKey("baz"); 553 const string kStringValue("string"); 554 donor.SetString(kStringKey, kStringValue); 555 const string kStringmapKey("stringMapKey"); 556 const map<string, string> kStringmapValue{ { "key", "value" } }; 557 donor.SetStringmap(kStringmapKey, kStringmapValue); 558 const string kStringsKey("stringsKey"); 559 const vector<string> kStringsValue{ "string0", "string1" }; 560 donor.SetStrings(kStringsKey, kStringsValue); 561 const string kUintKey("bun"); 562 const uint32_t kUintValue = 456; 563 donor.SetUint(kUintKey, kUintValue); 564 const string kUint16Key("uint16"); 565 const uint16_t kUint16Value = 456; 566 donor.SetUint16(kUint16Key, kUint16Value); 567 const string kUint8sKey("uint8s"); 568 const vector<uint8_t> kUint8sValue{ 1 }; 569 donor.SetUint8s(kUint8sKey, kUint8sValue); 570 const string kUint32sKey("uint32s"); 571 const vector<uint32_t> kUint32sValue{ 1 }; 572 donor.SetUint32s(kUint32sKey, kUint32sValue); 573 574 EXPECT_TRUE(store_.IsEmpty()); 575 store_.CopyFrom(donor); 576 EXPECT_FALSE(store_.IsEmpty()); 577 EXPECT_EQ(donor, store_); 578} 579 580TEST_F(KeyValueStoreTest, ConvertToVariantDictionary) { 581 static const char kStringKey[] = "StringKey"; 582 static const char kStringValue[] = "StringValue"; 583 static const char kStringmapKey[] = "StringmapKey"; 584 const map<string, string> kStringmapValue = { { "key", "value" } }; 585 static const char kStringsKey[] = "StringsKey"; 586 const vector<string> kStringsValue = {"StringsValue1", "StringsValue2"}; 587 static const char kBoolKey[] = "BoolKey"; 588 const bool kBoolValue = true; 589 static const char kInt32Key[] = "Int32Key"; 590 const int32_t kInt32Value = 123; 591 static const char kUint32Key[] = "Uint32Key"; 592 const uint32_t kUint32Value = 654; 593 static const char kByteArraysKey[] = "ByteArraysKey"; 594 const vector<vector<uint8_t>> kByteArraysValue{ {1}, {2} }; 595 static const char kInt16Key[] = "Int16Key"; 596 const int16_t kInt16Value = 123; 597 static const char kRpcIdentifierKey[] = "RpcIdentifierKey"; 598 static const char kRpcIdentifierValue[] = "/org/chromium/test"; 599 static const char kUint16Key[] = "Uint16Key"; 600 const uint16_t kUint16Value = 123; 601 static const char kUint8sKey[] = "Uint8sKey"; 602 const vector<uint8_t> kUint8sValue{ 1, 2 }; 603 static const char kUint32sKey[] = "Uint32sKey"; 604 const vector<uint32_t> kUint32sValue{ 1, 2 }; 605 static const char kKeyValueStoreKey[] = "KeyValueStoreKey"; 606 static const char kNestedInt32Key[] = "NestedKey32Key"; 607 const int32_t kNestedInt32Value = 1; 608 KeyValueStore nested_store; 609 nested_store.SetInt(kNestedInt32Key, kNestedInt32Value); 610 611 KeyValueStore store; 612 store.SetString(kStringKey, kStringValue); 613 store.SetStringmap(kStringmapKey, kStringmapValue); 614 store.SetStrings(kStringsKey, kStringsValue); 615 store.SetBool(kBoolKey, kBoolValue); 616 store.SetInt(kInt32Key, kInt32Value); 617 store.SetUint(kUint32Key, kUint32Value); 618 store.SetByteArrays(kByteArraysKey, kByteArraysValue); 619 store.SetInt16(kInt16Key, kInt16Value); 620 store.SetRpcIdentifier(kRpcIdentifierKey, kRpcIdentifierValue); 621 store.SetUint16(kUint16Key, kUint16Value); 622 store.SetUint8s(kUint8sKey, kUint8sValue); 623 store.SetUint32s(kUint32sKey, kUint32sValue); 624 store.SetKeyValueStore(kKeyValueStoreKey, nested_store); 625 626 brillo::VariantDictionary dict; 627 KeyValueStore::ConvertToVariantDictionary(store, &dict); 628 EXPECT_EQ(13, dict.size()); 629 EXPECT_EQ(kStringValue, dict[kStringKey].Get<string>()); 630 map<string, string> stringmap_value = 631 dict[kStringmapKey].Get<map<string, string>>(); 632 EXPECT_EQ(kStringmapValue, stringmap_value); 633 EXPECT_EQ(kStringsValue, dict[kStringsKey].Get<vector<string>>()); 634 EXPECT_EQ(kBoolValue, dict[kBoolKey].Get<bool>()); 635 EXPECT_EQ(kInt32Value, dict[kInt32Key].Get<int32_t>()); 636 EXPECT_EQ(kUint32Value, dict[kUint32Key].Get<uint32_t>()); 637 EXPECT_EQ(kByteArraysValue, 638 dict[kByteArraysKey].Get<vector<vector<uint8_t>>>()); 639 EXPECT_EQ(kInt16Value, dict[kInt16Key].Get<int16_t>()); 640 EXPECT_EQ(kRpcIdentifierValue, 641 dict[kRpcIdentifierKey].Get<dbus::ObjectPath>().value()); 642 EXPECT_EQ(kUint16Value, dict[kUint16Key].Get<uint16_t>()); 643 EXPECT_EQ(kUint8sValue, dict[kUint8sKey].Get<vector<uint8_t>>()); 644 EXPECT_EQ(kUint32sValue, dict[kUint32sKey].Get<vector<uint32_t>>()); 645 brillo::VariantDictionary nested_dict = 646 dict[kKeyValueStoreKey].Get<brillo::VariantDictionary>(); 647 EXPECT_EQ(kNestedInt32Value, nested_dict[kNestedInt32Key].Get<int32_t>()); 648} 649 650TEST_F(KeyValueStoreTest, ConvertFromVariantDictionary) { 651 static const char kStringKey[] = "StringKey"; 652 static const char kStringValue[] = "StringValue"; 653 static const char kStringmapKey[] = "StringmapKey"; 654 const map<string, string> kStringmapValue = { { "key", "value" } }; 655 static const char kStringsKey[] = "StringsKey"; 656 const vector<string> kStringsValue = {"StringsValue1", "StringsValue2"}; 657 static const char kBoolKey[] = "BoolKey"; 658 const bool kBoolValue = true; 659 static const char kInt32Key[] = "Int32Key"; 660 const int32_t kInt32Value = 123; 661 static const char kUint32Key[] = "Uint32Key"; 662 const uint32_t kUint32Value = 654; 663 static const char kByteArraysKey[] = "ByteArraysKey"; 664 const vector<vector<uint8_t>> kByteArraysValue{ {1}, {2} }; 665 static const char kInt16Key[] = "Int16Key"; 666 const int16_t kInt16Value = 123; 667 static const char kRpcIdentifierKey[] = "RpcIdentifierKey"; 668 static const char kRpcIdentifierValue[] = "/org/chromium/test"; 669 static const char kUint16Key[] = "Uint16Key"; 670 const uint16_t kUint16Value = 123; 671 static const char kUint8sKey[] = "Uint8sKey"; 672 const vector<uint8_t> kUint8sValue{ 1, 2 }; 673 static const char kUint32sKey[] = "Uint32sKey"; 674 const vector<uint32_t> kUint32sValue{ 1, 2 }; 675 static const char kKeyValueStoreKey[] = "KeyValueStoreKey"; 676 static const char kNestedInt32Key[] = "NestedKey32Key"; 677 const int32_t kNestedInt32Value = 1; 678 679 brillo::VariantDictionary dict; 680 dict[kStringKey] = brillo::Any(string(kStringValue)); 681 dict[kStringmapKey] = brillo::Any(kStringmapValue); 682 dict[kStringsKey] = brillo::Any(kStringsValue); 683 dict[kBoolKey] = brillo::Any(kBoolValue); 684 dict[kInt32Key] = brillo::Any(kInt32Value); 685 dict[kUint32Key] = brillo::Any(kUint32Value); 686 dict[kByteArraysKey] = brillo::Any(kByteArraysValue); 687 dict[kInt16Key] = brillo::Any(kInt16Value); 688 dict[kRpcIdentifierKey] = 689 brillo::Any(dbus::ObjectPath(kRpcIdentifierValue)); 690 dict[kUint16Key] = brillo::Any(kUint16Value); 691 dict[kUint8sKey] = brillo::Any(kUint8sValue); 692 dict[kUint32sKey] = brillo::Any(kUint32sValue); 693 brillo::VariantDictionary nested_dict; 694 nested_dict[kNestedInt32Key] = brillo::Any(kNestedInt32Value); 695 dict[kKeyValueStoreKey] = brillo::Any(nested_dict); 696 697 KeyValueStore store; 698 KeyValueStore::ConvertFromVariantDictionary(dict, &store); 699 EXPECT_TRUE(store.ContainsString(kStringKey)); 700 EXPECT_EQ(kStringValue, store.GetString(kStringKey)); 701 EXPECT_TRUE(store.ContainsStringmap(kStringmapKey)); 702 EXPECT_EQ(kStringmapValue, store.GetStringmap(kStringmapKey)); 703 EXPECT_TRUE(store.ContainsStrings(kStringsKey)); 704 EXPECT_EQ(kStringsValue, store.GetStrings(kStringsKey)); 705 EXPECT_TRUE(store.ContainsBool(kBoolKey)); 706 EXPECT_EQ(kBoolValue, store.GetBool(kBoolKey)); 707 EXPECT_TRUE(store.ContainsInt(kInt32Key)); 708 EXPECT_EQ(kInt32Value, store.GetInt(kInt32Key)); 709 EXPECT_TRUE(store.ContainsUint(kUint32Key)); 710 EXPECT_EQ(kUint32Value, store.GetUint(kUint32Key)); 711 EXPECT_TRUE(store.ContainsByteArrays(kByteArraysKey)); 712 EXPECT_EQ(kByteArraysValue, store.GetByteArrays(kByteArraysKey)); 713 EXPECT_TRUE(store.ContainsInt16(kInt16Key)); 714 EXPECT_EQ(kInt16Value, store.GetInt16(kInt16Key)); 715 EXPECT_TRUE(store.ContainsRpcIdentifier(kRpcIdentifierKey)); 716 EXPECT_EQ(kRpcIdentifierValue, store.GetRpcIdentifier(kRpcIdentifierKey)); 717 EXPECT_TRUE(store.ContainsUint16(kUint16Key)); 718 EXPECT_EQ(kUint16Value, store.GetUint16(kUint16Key)); 719 EXPECT_TRUE(store.ContainsUint8s(kUint8sKey)); 720 EXPECT_EQ(kUint8sValue, store.GetUint8s(kUint8sKey)); 721 EXPECT_TRUE(store.ContainsUint32s(kUint32sKey)); 722 EXPECT_EQ(kUint32sValue, store.GetUint32s(kUint32sKey)); 723 EXPECT_TRUE(store.ContainsKeyValueStore(kKeyValueStoreKey)); 724 KeyValueStore nested_store; 725 nested_store.SetInt(kNestedInt32Key, kNestedInt32Value); 726 EXPECT_EQ(nested_store, store.GetKeyValueStore(kKeyValueStoreKey)); 727} 728 729TEST_F(KeyValueStoreTest, ConvertPathsToRpcIdentifiers) { 730 const string kRpcIdentifier1("/test1"); 731 const string kRpcIdentifier2("/test2"); 732 vector<dbus::ObjectPath> paths; 733 paths.push_back(dbus::ObjectPath(kRpcIdentifier1)); 734 paths.push_back(dbus::ObjectPath(kRpcIdentifier2)); 735 vector<string> actual_rpc_identifiers; 736 KeyValueStore::ConvertPathsToRpcIdentifiers(paths, &actual_rpc_identifiers); 737 vector<string> expected_rpc_identifiers; 738 expected_rpc_identifiers.push_back(kRpcIdentifier1); 739 expected_rpc_identifiers.push_back(kRpcIdentifier2); 740 EXPECT_EQ(expected_rpc_identifiers, actual_rpc_identifiers); 741} 742 743} // namespace shill 744