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