dbus/values_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "dbus/values_util.h"
   6
   7 #include <vector>
   8
   9 #include "base/json/json_writer.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/values.h"
  12 #include "dbus/message.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace dbus {
  16
  17 TEST(ValuesUtilTest, PopBasicTypes) {
  18   scoped_ptr<Response> response(Response::CreateEmpty());
  19   // Append basic type values.
  20   MessageWriter writer(response.get());
  21   const uint8 kByteValue = 42;
  22   writer.AppendByte(kByteValue);
  23   const bool kBoolValue = true;
  24   writer.AppendBool(kBoolValue);
  25   const int16 kInt16Value = -43;
  26   writer.AppendInt16(kInt16Value);
  27   const uint16 kUint16Value = 44;
  28   writer.AppendUint16(kUint16Value);
  29   const int32 kInt32Value = -45;
  30   writer.AppendInt32(kInt32Value);
  31   const uint32 kUint32Value = 46;
  32   writer.AppendUint32(kUint32Value);
  33   const int64 kInt64Value = -47;
  34   writer.AppendInt64(kInt64Value);
  35   const uint64 kUint64Value = 48;
  36   writer.AppendUint64(kUint64Value);
  37   const double kDoubleValue = 4.9;
  38   writer.AppendDouble(kDoubleValue);
  39   const std::string kStringValue = "fifty";
  40   writer.AppendString(kStringValue);
  41   const std::string kEmptyStringValue;
  42   writer.AppendString(kEmptyStringValue);
  43   const ObjectPath kObjectPathValue("/ObjectPath");
  44   writer.AppendObjectPath(kObjectPathValue);
  45
  46   MessageReader reader(response.get());
  47   scoped_ptr<base::Value> value;
  48   scoped_ptr<base::Value> expected_value;
  49   // Pop a byte.
  50   value.reset(PopDataAsValue(&reader));
  51   ASSERT_TRUE(value.get() != NULL);
  52   expected_value.reset(new base::FundamentalValue(kByteValue));
  53   EXPECT_TRUE(value->Equals(expected_value.get()));
  54   // Pop a bool.
  55   value.reset(PopDataAsValue(&reader));
  56   ASSERT_TRUE(value.get() != NULL);
  57   expected_value.reset(new base::FundamentalValue(kBoolValue));
  58   EXPECT_TRUE(value->Equals(expected_value.get()));
  59   // Pop an int16.
  60   value.reset(PopDataAsValue(&reader));
  61   ASSERT_TRUE(value.get() != NULL);
  62   expected_value.reset(new base::FundamentalValue(kInt16Value));
  63   EXPECT_TRUE(value->Equals(expected_value.get()));
  64   // Pop a uint16.
  65   value.reset(PopDataAsValue(&reader));
  66   ASSERT_TRUE(value.get() != NULL);
  67   expected_value.reset(new base::FundamentalValue(kUint16Value));
  68   EXPECT_TRUE(value->Equals(expected_value.get()));
  69   // Pop an int32.
  70   value.reset(PopDataAsValue(&reader));
  71   ASSERT_TRUE(value.get() != NULL);
  72   expected_value.reset(new base::FundamentalValue(kInt32Value));
  73   EXPECT_TRUE(value->Equals(expected_value.get()));
  74   // Pop a uint32.
  75   value.reset(PopDataAsValue(&reader));
  76   ASSERT_TRUE(value.get() != NULL);
  77   expected_value.reset(
  78       new base::FundamentalValue(static_cast<double>(kUint32Value)));
  79   EXPECT_TRUE(value->Equals(expected_value.get()));
  80   // Pop an int64.
  81   value.reset(PopDataAsValue(&reader));
  82   ASSERT_TRUE(value.get() != NULL);
  83   expected_value.reset(
  84       new base::FundamentalValue(static_cast<double>(kInt64Value)));
  85   EXPECT_TRUE(value->Equals(expected_value.get()));
  86   // Pop a uint64.
  87   value.reset(PopDataAsValue(&reader));
  88   ASSERT_TRUE(value.get() != NULL);
  89   expected_value.reset(
  90       new base::FundamentalValue(static_cast<double>(kUint64Value)));
  91   EXPECT_TRUE(value->Equals(expected_value.get()));
  92   // Pop a double.
  93   value.reset(PopDataAsValue(&reader));
  94   ASSERT_TRUE(value.get() != NULL);
  95   expected_value.reset(new base::FundamentalValue(kDoubleValue));
  96   EXPECT_TRUE(value->Equals(expected_value.get()));
  97   // Pop a string.
  98   value.reset(PopDataAsValue(&reader));
  99   ASSERT_TRUE(value.get() != NULL);
 100   expected_value.reset(new base::StringValue(kStringValue));
 101   EXPECT_TRUE(value->Equals(expected_value.get()));
 102   // Pop an empty string.
 103   value.reset(PopDataAsValue(&reader));
 104   ASSERT_TRUE(value.get() != NULL);
 105   expected_value.reset(new base::StringValue(kEmptyStringValue));
 106   EXPECT_TRUE(value->Equals(expected_value.get()));
 107   // Pop an object path.
 108   value.reset(PopDataAsValue(&reader));
 109   ASSERT_TRUE(value.get() != NULL);
 110   expected_value.reset(new base::StringValue(kObjectPathValue.value()));
 111   EXPECT_TRUE(value->Equals(expected_value.get()));
 112 }
 113
 114 TEST(ValuesUtilTest, PopVariant) {
 115   scoped_ptr<Response> response(Response::CreateEmpty());
 116   // Append variant values.
 117   MessageWriter writer(response.get());
 118   const bool kBoolValue = true;
 119   writer.AppendVariantOfBool(kBoolValue);
 120   const int32 kInt32Value = -45;
 121   writer.AppendVariantOfInt32(kInt32Value);
 122   const double kDoubleValue = 4.9;
 123   writer.AppendVariantOfDouble(kDoubleValue);
 124   const std::string kStringValue = "fifty";
 125   writer.AppendVariantOfString(kStringValue);
 126
 127   MessageReader reader(response.get());
 128   scoped_ptr<base::Value> value;
 129   scoped_ptr<base::Value> expected_value;
 130   // Pop a bool.
 131   value.reset(PopDataAsValue(&reader));
 132   ASSERT_TRUE(value.get() != NULL);
 133   expected_value.reset(new base::FundamentalValue(kBoolValue));
 134   EXPECT_TRUE(value->Equals(expected_value.get()));
 135   // Pop an int32.
 136   value.reset(PopDataAsValue(&reader));
 137   ASSERT_TRUE(value.get() != NULL);
 138   expected_value.reset(new base::FundamentalValue(kInt32Value));
 139   EXPECT_TRUE(value->Equals(expected_value.get()));
 140   // Pop a double.
 141   value.reset(PopDataAsValue(&reader));
 142   ASSERT_TRUE(value.get() != NULL);
 143   expected_value.reset(new base::FundamentalValue(kDoubleValue));
 144   EXPECT_TRUE(value->Equals(expected_value.get()));
 145   // Pop a string.
 146   value.reset(PopDataAsValue(&reader));
 147   ASSERT_TRUE(value.get() != NULL);
 148   expected_value.reset(new base::StringValue(kStringValue));
 149   EXPECT_TRUE(value->Equals(expected_value.get()));
 150 }
 151
 152 // Pop extremely large integers which cannot be precisely represented in
 153 // double.
 154 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
 155   scoped_ptr<Response> response(Response::CreateEmpty());
 156   // Append large integers.
 157   MessageWriter writer(response.get());
 158   const int64 kInt64Value = -123456789012345689LL;
 159   writer.AppendInt64(kInt64Value);
 160   const uint64 kUint64Value = 9876543210987654321ULL;
 161   writer.AppendUint64(kUint64Value);
 162
 163   MessageReader reader(response.get());
 164   scoped_ptr<base::Value> value;
 165   scoped_ptr<base::Value> expected_value;
 166   double double_value = 0;
 167   // Pop an int64.
 168   value.reset(PopDataAsValue(&reader));
 169   ASSERT_TRUE(value.get() != NULL);
 170   expected_value.reset(
 171       new base::FundamentalValue(static_cast<double>(kInt64Value)));
 172   EXPECT_TRUE(value->Equals(expected_value.get()));
 173   ASSERT_TRUE(value->GetAsDouble(&double_value));
 174   EXPECT_NE(kInt64Value, static_cast<int64>(double_value));
 175   // Pop a uint64.
 176   value.reset(PopDataAsValue(&reader));
 177   ASSERT_TRUE(value.get() != NULL);
 178   expected_value.reset(
 179       new base::FundamentalValue(static_cast<double>(kUint64Value)));
 180   EXPECT_TRUE(value->Equals(expected_value.get()));
 181   ASSERT_TRUE(value->GetAsDouble(&double_value));
 182   EXPECT_NE(kUint64Value, static_cast<uint64>(double_value));
 183 }
 184
 185 TEST(ValuesUtilTest, PopIntArray) {
 186   scoped_ptr<Response> response(Response::CreateEmpty());
 187   // Append an int32 array.
 188   MessageWriter writer(response.get());
 189   MessageWriter sub_writer(NULL);
 190   std::vector<int32> data;
 191   data.push_back(0);
 192   data.push_back(1);
 193   data.push_back(2);
 194   writer.OpenArray("i", &sub_writer);
 195   for (size_t i = 0; i != data.size(); ++i)
 196     sub_writer.AppendInt32(data[i]);
 197   writer.CloseContainer(&sub_writer);
 198
 199   // Create the expected value.
 200   scoped_ptr<base::ListValue> list_value(new base::ListValue);
 201   for (size_t i = 0; i != data.size(); ++i)
 202     list_value->Append(new base::FundamentalValue(data[i]));
 203
 204   // Pop an int32 array.
 205   MessageReader reader(response.get());
 206   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 207   ASSERT_TRUE(value.get() != NULL);
 208   EXPECT_TRUE(value->Equals(list_value.get()));
 209 }
 210
 211 TEST(ValuesUtilTest, PopStringArray) {
 212   scoped_ptr<Response> response(Response::CreateEmpty());
 213   // Append a string array.
 214   MessageWriter writer(response.get());
 215   MessageWriter sub_writer(NULL);
 216   std::vector<std::string> data;
 217   data.push_back("Dreamlifter");
 218   data.push_back("Beluga");
 219   data.push_back("Mriya");
 220   writer.AppendArrayOfStrings(data);
 221
 222   // Create the expected value.
 223   scoped_ptr<base::ListValue> list_value(new base::ListValue);
 224   for (size_t i = 0; i != data.size(); ++i)
 225     list_value->Append(new base::StringValue(data[i]));
 226
 227   // Pop a string array.
 228   MessageReader reader(response.get());
 229   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 230   ASSERT_TRUE(value.get() != NULL);
 231   EXPECT_TRUE(value->Equals(list_value.get()));
 232 }
 233
 234 TEST(ValuesUtilTest, PopStruct) {
 235   scoped_ptr<Response> response(Response::CreateEmpty());
 236   // Append a struct.
 237   MessageWriter writer(response.get());
 238   MessageWriter sub_writer(NULL);
 239   writer.OpenStruct(&sub_writer);
 240   const bool kBoolValue = true;
 241   sub_writer.AppendBool(kBoolValue);
 242   const int32 kInt32Value = -123;
 243   sub_writer.AppendInt32(kInt32Value);
 244   const double kDoubleValue = 1.23;
 245   sub_writer.AppendDouble(kDoubleValue);
 246   const std::string kStringValue = "one two three";
 247   sub_writer.AppendString(kStringValue);
 248   writer.CloseContainer(&sub_writer);
 249
 250   // Create the expected value.
 251   base::ListValue list_value;
 252   list_value.Append(new base::FundamentalValue(kBoolValue));
 253   list_value.Append(new base::FundamentalValue(kInt32Value));
 254   list_value.Append(new base::FundamentalValue(kDoubleValue));
 255   list_value.Append(new base::StringValue(kStringValue));
 256
 257   // Pop a struct.
 258   MessageReader reader(response.get());
 259   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 260   ASSERT_TRUE(value.get() != NULL);
 261   EXPECT_TRUE(value->Equals(&list_value));
 262 }
 263
 264 TEST(ValuesUtilTest, PopStringToVariantDictionary) {
 265   scoped_ptr<Response> response(Response::CreateEmpty());
 266   // Append a dictionary.
 267   MessageWriter writer(response.get());
 268   MessageWriter sub_writer(NULL);
 269   MessageWriter entry_writer(NULL);
 270   writer.OpenArray("{sv}", &sub_writer);
 271   sub_writer.OpenDictEntry(&entry_writer);
 272   const std::string kKey1 = "one";
 273   entry_writer.AppendString(kKey1);
 274   const bool kBoolValue = true;
 275   entry_writer.AppendVariantOfBool(kBoolValue);
 276   sub_writer.CloseContainer(&entry_writer);
 277   sub_writer.OpenDictEntry(&entry_writer);
 278   const std::string kKey2 = "two";
 279   entry_writer.AppendString(kKey2);
 280   const int32 kInt32Value = -45;
 281   entry_writer.AppendVariantOfInt32(kInt32Value);
 282   sub_writer.CloseContainer(&entry_writer);
 283   sub_writer.OpenDictEntry(&entry_writer);
 284   const std::string kKey3 = "three";
 285   entry_writer.AppendString(kKey3);
 286   const double kDoubleValue = 4.9;
 287   entry_writer.AppendVariantOfDouble(kDoubleValue);
 288   sub_writer.CloseContainer(&entry_writer);
 289   sub_writer.OpenDictEntry(&entry_writer);
 290   const std::string kKey4 = "four";
 291   entry_writer.AppendString(kKey4);
 292   const std::string kStringValue = "fifty";
 293   entry_writer.AppendVariantOfString(kStringValue);
 294   sub_writer.CloseContainer(&entry_writer);
 295   writer.CloseContainer(&sub_writer);
 296
 297   // Create the expected value.
 298   base::DictionaryValue dictionary_value;
 299   dictionary_value.SetBoolean(kKey1, kBoolValue);
 300   dictionary_value.SetInteger(kKey2, kInt32Value);
 301   dictionary_value.SetDouble(kKey3, kDoubleValue);
 302   dictionary_value.SetString(kKey4, kStringValue);
 303
 304   // Pop a dictinoary.
 305   MessageReader reader(response.get());
 306   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 307   ASSERT_TRUE(value.get() != NULL);
 308   EXPECT_TRUE(value->Equals(&dictionary_value));
 309 }
 310
 311 TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) {
 312   scoped_ptr<Response> response(Response::CreateEmpty());
 313   // Append a dictionary.
 314   MessageWriter writer(response.get());
 315   MessageWriter sub_writer(NULL);
 316   MessageWriter entry_writer(NULL);
 317   writer.OpenArray("{sv}", &sub_writer);
 318   sub_writer.OpenDictEntry(&entry_writer);
 319   const std::string kKey1 = "www.example.com";  // String including dots.
 320   entry_writer.AppendString(kKey1);
 321   const bool kBoolValue = true;
 322   entry_writer.AppendVariantOfBool(kBoolValue);
 323   sub_writer.CloseContainer(&entry_writer);
 324   sub_writer.OpenDictEntry(&entry_writer);
 325   const std::string kKey2 = ".example";  // String starting with a dot.
 326   entry_writer.AppendString(kKey2);
 327   const int32 kInt32Value = -45;
 328   entry_writer.AppendVariantOfInt32(kInt32Value);
 329   sub_writer.CloseContainer(&entry_writer);
 330   sub_writer.OpenDictEntry(&entry_writer);
 331   const std::string kKey3 = "example.";  // String ending with a dot.
 332   entry_writer.AppendString(kKey3);
 333   const double kDoubleValue = 4.9;
 334   entry_writer.AppendVariantOfDouble(kDoubleValue);
 335   sub_writer.CloseContainer(&entry_writer);
 336   writer.CloseContainer(&sub_writer);
 337
 338   // Create the expected value.
 339   base::DictionaryValue dictionary_value;
 340   dictionary_value.SetWithoutPathExpansion(
 341       kKey1, new base::FundamentalValue(kBoolValue));
 342   dictionary_value.SetWithoutPathExpansion(
 343       kKey2, new base::FundamentalValue(kInt32Value));
 344   dictionary_value.SetWithoutPathExpansion(
 345       kKey3, new base::FundamentalValue(kDoubleValue));
 346
 347   // Pop a dictinoary.
 348   MessageReader reader(response.get());
 349   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 350   ASSERT_TRUE(value.get() != NULL);
 351   EXPECT_TRUE(value->Equals(&dictionary_value));
 352 }
 353
 354 TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
 355   // Create test data.
 356   const int32 kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
 357   const std::vector<int32> values(kValues, kValues + arraysize(kValues));
 358   std::vector<double> keys(values.size());
 359   for (size_t i = 0; i != values.size(); ++i)
 360     keys[i] = sqrt(values[i]);
 361
 362   // Append a dictionary.
 363   scoped_ptr<Response> response(Response::CreateEmpty());
 364   MessageWriter writer(response.get());
 365   MessageWriter sub_writer(NULL);
 366   writer.OpenArray("{di}", &sub_writer);
 367   for (size_t i = 0; i != values.size(); ++i) {
 368     MessageWriter entry_writer(NULL);
 369     sub_writer.OpenDictEntry(&entry_writer);
 370     entry_writer.AppendDouble(keys[i]);
 371     entry_writer.AppendInt32(values[i]);
 372     sub_writer.CloseContainer(&entry_writer);
 373   }
 374   writer.CloseContainer(&sub_writer);
 375
 376   // Create the expected value.
 377   base::DictionaryValue dictionary_value;
 378   for (size_t i = 0; i != values.size(); ++i) {
 379     scoped_ptr<base::Value> key_value(new base::FundamentalValue(keys[i]));
 380     std::string key_string;
 381     base::JSONWriter::Write(key_value.get(), &key_string);
 382     dictionary_value.SetWithoutPathExpansion(
 383         key_string, new base::FundamentalValue(values[i]));
 384   }
 385
 386   // Pop a dictionary.
 387   MessageReader reader(response.get());
 388   scoped_ptr<base::Value> value(PopDataAsValue(&reader));
 389   ASSERT_TRUE(value.get() != NULL);
 390   EXPECT_TRUE(value->Equals(&dictionary_value));
 391 }
 392
 393 TEST(ValuesUtilTest, AppendBasicTypes) {
 394   const base::FundamentalValue kBoolValue(false);
 395   const base::FundamentalValue kIntegerValue(42);
 396   const base::FundamentalValue kDoubleValue(4.2);
 397   const base::StringValue kStringValue("string");
 398
 399   scoped_ptr<Response> response(Response::CreateEmpty());
 400   MessageWriter writer(response.get());
 401   AppendBasicTypeValueData(&writer, kBoolValue);
 402   AppendBasicTypeValueData(&writer, kIntegerValue);
 403   AppendBasicTypeValueData(&writer, kDoubleValue);
 404   AppendBasicTypeValueData(&writer, kStringValue);
 405
 406   MessageReader reader(response.get());
 407   scoped_ptr<base::Value> value;
 408   value.reset(PopDataAsValue(&reader));
 409   ASSERT_TRUE(value.get() != NULL);
 410   EXPECT_TRUE(value->Equals(&kBoolValue));
 411   value.reset(PopDataAsValue(&reader));
 412   ASSERT_TRUE(value.get() != NULL);
 413   EXPECT_TRUE(value->Equals(&kIntegerValue));
 414   value.reset(PopDataAsValue(&reader));
 415   ASSERT_TRUE(value.get() != NULL);
 416   EXPECT_TRUE(value->Equals(&kDoubleValue));
 417   value.reset(PopDataAsValue(&reader));
 418   ASSERT_TRUE(value.get() != NULL);
 419   EXPECT_TRUE(value->Equals(&kStringValue));
 420 }
 421
 422 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
 423   const base::FundamentalValue kBoolValue(false);
 424   const base::FundamentalValue kIntegerValue(42);
 425   const base::FundamentalValue kDoubleValue(4.2);
 426   const base::StringValue kStringValue("string");
 427
 428   scoped_ptr<Response> response(Response::CreateEmpty());
 429   MessageWriter writer(response.get());
 430   AppendBasicTypeValueDataAsVariant(&writer, kBoolValue);
 431   AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue);
 432   AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue);
 433   AppendBasicTypeValueDataAsVariant(&writer, kStringValue);
 434
 435   MessageReader reader(response.get());
 436   scoped_ptr<base::Value> value;
 437   value.reset(PopDataAsValue(&reader));
 438   ASSERT_TRUE(value.get() != NULL);
 439   EXPECT_TRUE(value->Equals(&kBoolValue));
 440   value.reset(PopDataAsValue(&reader));
 441   ASSERT_TRUE(value.get() != NULL);
 442   EXPECT_TRUE(value->Equals(&kIntegerValue));
 443   value.reset(PopDataAsValue(&reader));
 444   ASSERT_TRUE(value.get() != NULL);
 445   EXPECT_TRUE(value->Equals(&kDoubleValue));
 446   value.reset(PopDataAsValue(&reader));
 447   ASSERT_TRUE(value.get() != NULL);
 448   EXPECT_TRUE(value->Equals(&kStringValue));
 449 }
 450
 451 TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
 452   const base::FundamentalValue kBoolValue(false);
 453   const base::FundamentalValue kIntegerValue(42);
 454   const base::FundamentalValue kDoubleValue(4.2);
 455   const base::StringValue kStringValue("string");
 456
 457   scoped_ptr<Response> response(Response::CreateEmpty());
 458   MessageWriter writer(response.get());
 459   AppendValueData(&writer, kBoolValue);
 460   AppendValueData(&writer, kIntegerValue);
 461   AppendValueData(&writer, kDoubleValue);
 462   AppendValueData(&writer, kStringValue);
 463
 464   MessageReader reader(response.get());
 465   scoped_ptr<base::Value> value;
 466   value.reset(PopDataAsValue(&reader));
 467   ASSERT_TRUE(value.get() != NULL);
 468   EXPECT_TRUE(value->Equals(&kBoolValue));
 469   value.reset(PopDataAsValue(&reader));
 470   ASSERT_TRUE(value.get() != NULL);
 471   EXPECT_TRUE(value->Equals(&kIntegerValue));
 472   value.reset(PopDataAsValue(&reader));
 473   ASSERT_TRUE(value.get() != NULL);
 474   EXPECT_TRUE(value->Equals(&kDoubleValue));
 475   value.reset(PopDataAsValue(&reader));
 476   ASSERT_TRUE(value.get() != NULL);
 477   EXPECT_TRUE(value->Equals(&kStringValue));
 478 }
 479
 480 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) {
 481   const base::FundamentalValue kBoolValue(false);
 482   const base::FundamentalValue kIntegerValue(42);
 483   const base::FundamentalValue kDoubleValue(4.2);
 484   const base::StringValue kStringValue("string");
 485
 486   scoped_ptr<Response> response(Response::CreateEmpty());
 487   MessageWriter writer(response.get());
 488   AppendValueDataAsVariant(&writer, kBoolValue);
 489   AppendValueDataAsVariant(&writer, kIntegerValue);
 490   AppendValueDataAsVariant(&writer, kDoubleValue);
 491   AppendValueDataAsVariant(&writer, kStringValue);
 492
 493   MessageReader reader(response.get());
 494   scoped_ptr<base::Value> value;
 495   value.reset(PopDataAsValue(&reader));
 496   ASSERT_TRUE(value.get() != NULL);
 497   EXPECT_TRUE(value->Equals(&kBoolValue));
 498   value.reset(PopDataAsValue(&reader));
 499   ASSERT_TRUE(value.get() != NULL);
 500   EXPECT_TRUE(value->Equals(&kIntegerValue));
 501   value.reset(PopDataAsValue(&reader));
 502   ASSERT_TRUE(value.get() != NULL);
 503   EXPECT_TRUE(value->Equals(&kDoubleValue));
 504   value.reset(PopDataAsValue(&reader));
 505   ASSERT_TRUE(value.get() != NULL);
 506   EXPECT_TRUE(value->Equals(&kStringValue));
 507 }
 508
 509 TEST(ValuesUtilTest, AppendDictionary) {
 510   // Set up the input dictionary.
 511   const std::string kKey1 = "one";
 512   const std::string kKey2 = "two";
 513   const std::string kKey3 = "three";
 514   const std::string kKey4 = "four";
 515   const std::string kKey5 = "five";
 516   const std::string kKey6 = "six";
 517
 518   const bool kBoolValue = true;
 519   const int32 kInt32Value = -45;
 520   const double kDoubleValue = 4.9;
 521   const std::string kStringValue = "fifty";
 522
 523   base::ListValue* list_value = new base::ListValue();
 524   list_value->AppendBoolean(kBoolValue);
 525   list_value->AppendInteger(kInt32Value);
 526
 527   base::DictionaryValue* dictionary_value = new base::DictionaryValue();
 528   dictionary_value->SetBoolean(kKey1, kBoolValue);
 529   dictionary_value->SetInteger(kKey2, kDoubleValue);
 530
 531   base::DictionaryValue test_dictionary;
 532   test_dictionary.SetBoolean(kKey1, kBoolValue);
 533   test_dictionary.SetInteger(kKey2, kInt32Value);
 534   test_dictionary.SetDouble(kKey3, kDoubleValue);
 535   test_dictionary.SetString(kKey4, kStringValue);
 536   test_dictionary.Set(kKey5, list_value);  // takes ownership
 537   test_dictionary.Set(kKey6, dictionary_value);  // takes ownership
 538
 539   scoped_ptr<Response> response(Response::CreateEmpty());
 540   MessageWriter writer(response.get());
 541   AppendValueData(&writer, test_dictionary);
 542   base::FundamentalValue int_value(kInt32Value);
 543   AppendValueData(&writer, int_value);
 544
 545   // Read the data.
 546   MessageReader reader(response.get());
 547   scoped_ptr<base::Value> value;
 548   value.reset(PopDataAsValue(&reader));
 549   ASSERT_TRUE(value.get() != NULL);
 550   EXPECT_TRUE(value->Equals(&test_dictionary));
 551   value.reset(PopDataAsValue(&reader));
 552   ASSERT_TRUE(value.get() != NULL);
 553   EXPECT_TRUE(value->Equals(&int_value));
 554 }
 555
 556 TEST(ValuesUtilTest, AppendDictionaryAsVariant) {
 557   // Set up the input dictionary.
 558   const std::string kKey1 = "one";
 559   const std::string kKey2 = "two";
 560   const std::string kKey3 = "three";
 561   const std::string kKey4 = "four";
 562   const std::string kKey5 = "five";
 563   const std::string kKey6 = "six";
 564
 565   const bool kBoolValue = true;
 566   const int32 kInt32Value = -45;
 567   const double kDoubleValue = 4.9;
 568   const std::string kStringValue = "fifty";
 569
 570   base::ListValue* list_value = new base::ListValue();
 571   list_value->AppendBoolean(kBoolValue);
 572   list_value->AppendInteger(kInt32Value);
 573
 574   base::DictionaryValue* dictionary_value = new base::DictionaryValue();
 575   dictionary_value->SetBoolean(kKey1, kBoolValue);
 576   dictionary_value->SetInteger(kKey2, kDoubleValue);
 577
 578   base::DictionaryValue test_dictionary;
 579   test_dictionary.SetBoolean(kKey1, kBoolValue);
 580   test_dictionary.SetInteger(kKey2, kInt32Value);
 581   test_dictionary.SetDouble(kKey3, kDoubleValue);
 582   test_dictionary.SetString(kKey4, kStringValue);
 583   test_dictionary.Set(kKey5, list_value);  // takes ownership
 584   test_dictionary.Set(kKey6, dictionary_value);  // takes ownership
 585
 586   scoped_ptr<Response> response(Response::CreateEmpty());
 587   MessageWriter writer(response.get());
 588   AppendValueDataAsVariant(&writer, test_dictionary);
 589   base::FundamentalValue int_value(kInt32Value);
 590   AppendValueData(&writer, int_value);
 591
 592   // Read the data.
 593   MessageReader reader(response.get());
 594   scoped_ptr<base::Value> value;
 595   value.reset(PopDataAsValue(&reader));
 596   ASSERT_TRUE(value.get() != NULL);
 597   EXPECT_TRUE(value->Equals(&test_dictionary));
 598   value.reset(PopDataAsValue(&reader));
 599   ASSERT_TRUE(value.get() != NULL);
 600   EXPECT_TRUE(value->Equals(&int_value));
 601 }
 602
 603 TEST(ValuesUtilTest, AppendList) {
 604   // Set up the input list.
 605   const std::string kKey1 = "one";
 606   const std::string kKey2 = "two";
 607
 608   const bool kBoolValue = true;
 609   const int32 kInt32Value = -45;
 610   const double kDoubleValue = 4.9;
 611   const std::string kStringValue = "fifty";
 612
 613   base::ListValue* list_value = new base::ListValue();
 614   list_value->AppendBoolean(kBoolValue);
 615   list_value->AppendInteger(kInt32Value);
 616
 617   base::DictionaryValue* dictionary_value = new base::DictionaryValue();
 618   dictionary_value->SetBoolean(kKey1, kBoolValue);
 619   dictionary_value->SetInteger(kKey2, kDoubleValue);
 620
 621   base::ListValue test_list;
 622   test_list.AppendBoolean(kBoolValue);
 623   test_list.AppendInteger(kInt32Value);
 624   test_list.AppendDouble(kDoubleValue);
 625   test_list.AppendString(kStringValue);
 626   test_list.Append(list_value);  // takes ownership
 627   test_list.Append(dictionary_value);  // takes ownership
 628
 629   scoped_ptr<Response> response(Response::CreateEmpty());
 630   MessageWriter writer(response.get());
 631   AppendValueData(&writer, test_list);
 632   base::FundamentalValue int_value(kInt32Value);
 633   AppendValueData(&writer, int_value);
 634
 635   // Read the data.
 636   MessageReader reader(response.get());
 637   scoped_ptr<base::Value> value;
 638   value.reset(PopDataAsValue(&reader));
 639   ASSERT_TRUE(value.get() != NULL);
 640   EXPECT_TRUE(value->Equals(&test_list));
 641   value.reset(PopDataAsValue(&reader));
 642   ASSERT_TRUE(value.get() != NULL);
 643   EXPECT_TRUE(value->Equals(&int_value));
 644 }
 645
 646 TEST(ValuesUtilTest, AppendListAsVariant) {
 647   // Set up the input list.
 648   const std::string kKey1 = "one";
 649   const std::string kKey2 = "two";
 650
 651   const bool kBoolValue = true;
 652   const int32 kInt32Value = -45;
 653   const double kDoubleValue = 4.9;
 654   const std::string kStringValue = "fifty";
 655
 656   base::ListValue* list_value = new base::ListValue();
 657   list_value->AppendBoolean(kBoolValue);
 658   list_value->AppendInteger(kInt32Value);
 659
 660   base::DictionaryValue* dictionary_value = new base::DictionaryValue();
 661   dictionary_value->SetBoolean(kKey1, kBoolValue);
 662   dictionary_value->SetInteger(kKey2, kDoubleValue);
 663
 664   base::ListValue test_list;
 665   test_list.AppendBoolean(kBoolValue);
 666   test_list.AppendInteger(kInt32Value);
 667   test_list.AppendDouble(kDoubleValue);
 668   test_list.AppendString(kStringValue);
 669   test_list.Append(list_value);  // takes ownership
 670   test_list.Append(dictionary_value);  // takes ownership
 671
 672   scoped_ptr<Response> response(Response::CreateEmpty());
 673   MessageWriter writer(response.get());
 674   AppendValueDataAsVariant(&writer, test_list);
 675   base::FundamentalValue int_value(kInt32Value);
 676   AppendValueData(&writer, int_value);
 677
 678   // Read the data.
 679   MessageReader reader(response.get());
 680   scoped_ptr<base::Value> value;
 681   value.reset(PopDataAsValue(&reader));
 682   ASSERT_TRUE(value.get() != NULL);
 683   EXPECT_TRUE(value->Equals(&test_list));
 684   value.reset(PopDataAsValue(&reader));
 685   ASSERT_TRUE(value.get() != NULL);
 686   EXPECT_TRUE(value->Equals(&int_value));
 687 }
 688
 689 }  // namespace dbus