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 TEST(ValuesUtilTest, PopBasicTypes) {
  17   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
  18   // Append basic type values.
  19   dbus::MessageWriter writer(response.get());
  20   const uint8 kByteValue = 42;
  21   writer.AppendByte(kByteValue);
  22   const bool kBoolValue = true;
  23   writer.AppendBool(kBoolValue);
  24   const int16 kInt16Value = -43;
  25   writer.AppendInt16(kInt16Value);
  26   const uint16 kUint16Value = 44;
  27   writer.AppendUint16(kUint16Value);
  28   const int32 kInt32Value = -45;
  29   writer.AppendInt32(kInt32Value);
  30   const uint32 kUint32Value = 46;
  31   writer.AppendUint32(kUint32Value);
  32   const int64 kInt64Value = -47;
  33   writer.AppendInt64(kInt64Value);
  34   const uint64 kUint64Value = 48;
  35   writer.AppendUint64(kUint64Value);
  36   const double kDoubleValue = 4.9;
  37   writer.AppendDouble(kDoubleValue);
  38   const std::string kStringValue = "fifty";
  39   writer.AppendString(kStringValue);
  40   const std::string kEmptyStringValue;
  41   writer.AppendString(kEmptyStringValue);
  42   const dbus::ObjectPath kObjectPathValue("/ObjectPath");
  43   writer.AppendObjectPath(kObjectPathValue);
  44
  45   dbus::MessageReader reader(response.get());
  46   scoped_ptr<base::Value> value;
  47   scoped_ptr<base::Value> expected_value;
  48   // Pop a byte.
  49   value.reset(dbus::PopDataAsValue(&reader));
  50   ASSERT_TRUE(value.get() != NULL);
  51   expected_value.reset(new base::FundamentalValue(kByteValue));
  52   EXPECT_TRUE(value->Equals(expected_value.get()));
  53   // Pop a bool.
  54   value.reset(dbus::PopDataAsValue(&reader));
  55   ASSERT_TRUE(value.get() != NULL);
  56   expected_value.reset(new base::FundamentalValue(kBoolValue));
  57   EXPECT_TRUE(value->Equals(expected_value.get()));
  58   // Pop an int16.
  59   value.reset(dbus::PopDataAsValue(&reader));
  60   ASSERT_TRUE(value.get() != NULL);
  61   expected_value.reset(new base::FundamentalValue(kInt16Value));
  62   EXPECT_TRUE(value->Equals(expected_value.get()));
  63   // Pop a uint16.
  64   value.reset(dbus::PopDataAsValue(&reader));
  65   ASSERT_TRUE(value.get() != NULL);
  66   expected_value.reset(new base::FundamentalValue(kUint16Value));
  67   EXPECT_TRUE(value->Equals(expected_value.get()));
  68   // Pop an int32.
  69   value.reset(dbus::PopDataAsValue(&reader));
  70   ASSERT_TRUE(value.get() != NULL);
  71   expected_value.reset(new base::FundamentalValue(kInt32Value));
  72   EXPECT_TRUE(value->Equals(expected_value.get()));
  73   // Pop a uint32.
  74   value.reset(dbus::PopDataAsValue(&reader));
  75   ASSERT_TRUE(value.get() != NULL);
  76   expected_value.reset(
  77       new base::FundamentalValue(static_cast<double>(kUint32Value)));
  78   EXPECT_TRUE(value->Equals(expected_value.get()));
  79   // Pop an int64.
  80   value.reset(dbus::PopDataAsValue(&reader));
  81   ASSERT_TRUE(value.get() != NULL);
  82   expected_value.reset(
  83       new base::FundamentalValue(static_cast<double>(kInt64Value)));
  84   EXPECT_TRUE(value->Equals(expected_value.get()));
  85   // Pop a uint64.
  86   value.reset(dbus::PopDataAsValue(&reader));
  87   ASSERT_TRUE(value.get() != NULL);
  88   expected_value.reset(
  89       new base::FundamentalValue(static_cast<double>(kUint64Value)));
  90   EXPECT_TRUE(value->Equals(expected_value.get()));
  91   // Pop a double.
  92   value.reset(dbus::PopDataAsValue(&reader));
  93   ASSERT_TRUE(value.get() != NULL);
  94   expected_value.reset(new base::FundamentalValue(kDoubleValue));
  95   EXPECT_TRUE(value->Equals(expected_value.get()));
  96   // Pop a string.
  97   value.reset(dbus::PopDataAsValue(&reader));
  98   ASSERT_TRUE(value.get() != NULL);
  99   expected_value.reset(new base::StringValue(kStringValue));
 100   EXPECT_TRUE(value->Equals(expected_value.get()));
 101   // Pop an empty string.
 102   value.reset(dbus::PopDataAsValue(&reader));
 103   ASSERT_TRUE(value.get() != NULL);
 104   expected_value.reset(new base::StringValue(kEmptyStringValue));
 105   EXPECT_TRUE(value->Equals(expected_value.get()));
 106   // Pop an object path.
 107   value.reset(dbus::PopDataAsValue(&reader));
 108   ASSERT_TRUE(value.get() != NULL);
 109   expected_value.reset(new base::StringValue(kObjectPathValue.value()));
 110   EXPECT_TRUE(value->Equals(expected_value.get()));
 111 }
 112
 113 TEST(ValuesUtilTest, PopVariant) {
 114   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 115   // Append variant values.
 116   dbus::MessageWriter writer(response.get());
 117   const bool kBoolValue = true;
 118   writer.AppendVariantOfBool(kBoolValue);
 119   const int32 kInt32Value = -45;
 120   writer.AppendVariantOfInt32(kInt32Value);
 121   const double kDoubleValue = 4.9;
 122   writer.AppendVariantOfDouble(kDoubleValue);
 123   const std::string kStringValue = "fifty";
 124   writer.AppendVariantOfString(kStringValue);
 125
 126   dbus::MessageReader reader(response.get());
 127   scoped_ptr<base::Value> value;
 128   scoped_ptr<base::Value> expected_value;
 129   // Pop a bool.
 130   value.reset(dbus::PopDataAsValue(&reader));
 131   ASSERT_TRUE(value.get() != NULL);
 132   expected_value.reset(new base::FundamentalValue(kBoolValue));
 133   EXPECT_TRUE(value->Equals(expected_value.get()));
 134   // Pop an int32.
 135   value.reset(dbus::PopDataAsValue(&reader));
 136   ASSERT_TRUE(value.get() != NULL);
 137   expected_value.reset(new base::FundamentalValue(kInt32Value));
 138   EXPECT_TRUE(value->Equals(expected_value.get()));
 139   // Pop a double.
 140   value.reset(dbus::PopDataAsValue(&reader));
 141   ASSERT_TRUE(value.get() != NULL);
 142   expected_value.reset(new base::FundamentalValue(kDoubleValue));
 143   EXPECT_TRUE(value->Equals(expected_value.get()));
 144   // Pop a string.
 145   value.reset(dbus::PopDataAsValue(&reader));
 146   ASSERT_TRUE(value.get() != NULL);
 147   expected_value.reset(new base::StringValue(kStringValue));
 148   EXPECT_TRUE(value->Equals(expected_value.get()));
 149 }
 150
 151 // Pop extremely large integers which cannot be precisely represented in
 152 // double.
 153 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
 154   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 155   // Append large integers.
 156   dbus::MessageWriter writer(response.get());
 157   const int64 kInt64Value = -123456789012345689LL;
 158   writer.AppendInt64(kInt64Value);
 159   const uint64 kUint64Value = 9876543210987654321ULL;
 160   writer.AppendUint64(kUint64Value);
 161
 162   dbus::MessageReader reader(response.get());
 163   scoped_ptr<base::Value> value;
 164   scoped_ptr<base::Value> expected_value;
 165   double double_value = 0;
 166   // Pop an int64.
 167   value.reset(dbus::PopDataAsValue(&reader));
 168   ASSERT_TRUE(value.get() != NULL);
 169   expected_value.reset(
 170       new base::FundamentalValue(static_cast<double>(kInt64Value)));
 171   EXPECT_TRUE(value->Equals(expected_value.get()));
 172   ASSERT_TRUE(value->GetAsDouble(&double_value));
 173   EXPECT_NE(kInt64Value, static_cast<int64>(double_value));
 174   // Pop a uint64.
 175   value.reset(dbus::PopDataAsValue(&reader));
 176   ASSERT_TRUE(value.get() != NULL);
 177   expected_value.reset(
 178       new base::FundamentalValue(static_cast<double>(kUint64Value)));
 179   EXPECT_TRUE(value->Equals(expected_value.get()));
 180   ASSERT_TRUE(value->GetAsDouble(&double_value));
 181   EXPECT_NE(kUint64Value, static_cast<uint64>(double_value));
 182 }
 183
 184 TEST(ValuesUtilTest, PopIntArray) {
 185   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 186   // Append an int32 array.
 187   dbus::MessageWriter writer(response.get());
 188   dbus::MessageWriter sub_writer(NULL);
 189   std::vector<int32> data;
 190   data.push_back(0);
 191   data.push_back(1);
 192   data.push_back(2);
 193   writer.OpenArray("i", &sub_writer);
 194   for (size_t i = 0; i != data.size(); ++i)
 195     sub_writer.AppendInt32(data[i]);
 196   writer.CloseContainer(&sub_writer);
 197
 198   // Create the expected value.
 199   scoped_ptr<base::ListValue> list_value(new base::ListValue);
 200   for (size_t i = 0; i != data.size(); ++i)
 201     list_value->Append(new base::FundamentalValue(data[i]));
 202
 203   // Pop an int32 array.
 204   dbus::MessageReader reader(response.get());
 205   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 206   ASSERT_TRUE(value.get() != NULL);
 207   EXPECT_TRUE(value->Equals(list_value.get()));
 208 }
 209
 210 TEST(ValuesUtilTest, PopStringArray) {
 211   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 212   // Append a string array.
 213   dbus::MessageWriter writer(response.get());
 214   dbus::MessageWriter sub_writer(NULL);
 215   std::vector<std::string> data;
 216   data.push_back("Dreamlifter");
 217   data.push_back("Beluga");
 218   data.push_back("Mriya");
 219   writer.AppendArrayOfStrings(data);
 220
 221   // Create the expected value.
 222   scoped_ptr<base::ListValue> list_value(new base::ListValue);
 223   for (size_t i = 0; i != data.size(); ++i)
 224     list_value->Append(new base::StringValue(data[i]));
 225
 226   // Pop a string array.
 227   dbus::MessageReader reader(response.get());
 228   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 229   ASSERT_TRUE(value.get() != NULL);
 230   EXPECT_TRUE(value->Equals(list_value.get()));
 231 }
 232
 233 TEST(ValuesUtilTest, PopStruct) {
 234   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 235   // Append a struct.
 236   dbus::MessageWriter writer(response.get());
 237   dbus::MessageWriter sub_writer(NULL);
 238   writer.OpenStruct(&sub_writer);
 239   const bool kBoolValue = true;
 240   sub_writer.AppendBool(kBoolValue);
 241   const int32 kInt32Value = -123;
 242   sub_writer.AppendInt32(kInt32Value);
 243   const double kDoubleValue = 1.23;
 244   sub_writer.AppendDouble(kDoubleValue);
 245   const std::string kStringValue = "one two three";
 246   sub_writer.AppendString(kStringValue);
 247   writer.CloseContainer(&sub_writer);
 248
 249   // Create the expected value.
 250   base::ListValue list_value;
 251   list_value.Append(new base::FundamentalValue(kBoolValue));
 252   list_value.Append(new base::FundamentalValue(kInt32Value));
 253   list_value.Append(new base::FundamentalValue(kDoubleValue));
 254   list_value.Append(new base::StringValue(kStringValue));
 255
 256   // Pop a struct.
 257   dbus::MessageReader reader(response.get());
 258   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 259   ASSERT_TRUE(value.get() != NULL);
 260   EXPECT_TRUE(value->Equals(&list_value));
 261 }
 262
 263 TEST(ValuesUtilTest, PopStringToVariantDictionary) {
 264   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 265   // Append a dictionary.
 266   dbus::MessageWriter writer(response.get());
 267   dbus::MessageWriter sub_writer(NULL);
 268   dbus::MessageWriter entry_writer(NULL);
 269   writer.OpenArray("{sv}", &sub_writer);
 270   sub_writer.OpenDictEntry(&entry_writer);
 271   const std::string kKey1 = "one";
 272   entry_writer.AppendString(kKey1);
 273   const bool kBoolValue = true;
 274   entry_writer.AppendVariantOfBool(kBoolValue);
 275   sub_writer.CloseContainer(&entry_writer);
 276   sub_writer.OpenDictEntry(&entry_writer);
 277   const std::string kKey2 = "two";
 278   entry_writer.AppendString(kKey2);
 279   const int32 kInt32Value = -45;
 280   entry_writer.AppendVariantOfInt32(kInt32Value);
 281   sub_writer.CloseContainer(&entry_writer);
 282   sub_writer.OpenDictEntry(&entry_writer);
 283   const std::string kKey3 = "three";
 284   entry_writer.AppendString(kKey3);
 285   const double kDoubleValue = 4.9;
 286   entry_writer.AppendVariantOfDouble(kDoubleValue);
 287   sub_writer.CloseContainer(&entry_writer);
 288   sub_writer.OpenDictEntry(&entry_writer);
 289   const std::string kKey4 = "four";
 290   entry_writer.AppendString(kKey4);
 291   const std::string kStringValue = "fifty";
 292   entry_writer.AppendVariantOfString(kStringValue);
 293   sub_writer.CloseContainer(&entry_writer);
 294   writer.CloseContainer(&sub_writer);
 295
 296   // Create the expected value.
 297   base::DictionaryValue dictionary_value;
 298   dictionary_value.SetBoolean(kKey1, kBoolValue);
 299   dictionary_value.SetInteger(kKey2, kInt32Value);
 300   dictionary_value.SetDouble(kKey3, kDoubleValue);
 301   dictionary_value.SetString(kKey4, kStringValue);
 302
 303   // Pop a dictinoary.
 304   dbus::MessageReader reader(response.get());
 305   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 306   ASSERT_TRUE(value.get() != NULL);
 307   EXPECT_TRUE(value->Equals(&dictionary_value));
 308 }
 309
 310 TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) {
 311   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 312   // Append a dictionary.
 313   dbus::MessageWriter writer(response.get());
 314   dbus::MessageWriter sub_writer(NULL);
 315   dbus::MessageWriter entry_writer(NULL);
 316   writer.OpenArray("{sv}", &sub_writer);
 317   sub_writer.OpenDictEntry(&entry_writer);
 318   const std::string kKey1 = "www.example.com";  // String including dots.
 319   entry_writer.AppendString(kKey1);
 320   const bool kBoolValue = true;
 321   entry_writer.AppendVariantOfBool(kBoolValue);
 322   sub_writer.CloseContainer(&entry_writer);
 323   sub_writer.OpenDictEntry(&entry_writer);
 324   const std::string kKey2 = ".example";  // String starting with a dot.
 325   entry_writer.AppendString(kKey2);
 326   const int32 kInt32Value = -45;
 327   entry_writer.AppendVariantOfInt32(kInt32Value);
 328   sub_writer.CloseContainer(&entry_writer);
 329   sub_writer.OpenDictEntry(&entry_writer);
 330   const std::string kKey3 = "example.";  // String ending with a dot.
 331   entry_writer.AppendString(kKey3);
 332   const double kDoubleValue = 4.9;
 333   entry_writer.AppendVariantOfDouble(kDoubleValue);
 334   sub_writer.CloseContainer(&entry_writer);
 335   writer.CloseContainer(&sub_writer);
 336
 337   // Create the expected value.
 338   base::DictionaryValue dictionary_value;
 339   dictionary_value.SetWithoutPathExpansion(
 340       kKey1, new base::FundamentalValue(kBoolValue));
 341   dictionary_value.SetWithoutPathExpansion(
 342       kKey2, new base::FundamentalValue(kInt32Value));
 343   dictionary_value.SetWithoutPathExpansion(
 344       kKey3, new base::FundamentalValue(kDoubleValue));
 345
 346   // Pop a dictinoary.
 347   dbus::MessageReader reader(response.get());
 348   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 349   ASSERT_TRUE(value.get() != NULL);
 350   EXPECT_TRUE(value->Equals(&dictionary_value));
 351 }
 352
 353 TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
 354   // Create test data.
 355   const int32 kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
 356   const std::vector<int32> values(kValues, kValues + arraysize(kValues));
 357   std::vector<double> keys(values.size());
 358   for (size_t i = 0; i != values.size(); ++i)
 359     keys[i] = sqrt(values[i]);
 360
 361   // Append a dictionary.
 362   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 363   dbus::MessageWriter writer(response.get());
 364   dbus::MessageWriter sub_writer(NULL);
 365   writer.OpenArray("{di}", &sub_writer);
 366   for (size_t i = 0; i != values.size(); ++i) {
 367     dbus::MessageWriter entry_writer(NULL);
 368     sub_writer.OpenDictEntry(&entry_writer);
 369     entry_writer.AppendDouble(keys[i]);
 370     entry_writer.AppendInt32(values[i]);
 371     sub_writer.CloseContainer(&entry_writer);
 372   }
 373   writer.CloseContainer(&sub_writer);
 374
 375   // Create the expected value.
 376   base::DictionaryValue dictionary_value;
 377   for (size_t i = 0; i != values.size(); ++i) {
 378     scoped_ptr<base::Value> key_value(new base::FundamentalValue(keys[i]));
 379     std::string key_string;
 380     base::JSONWriter::Write(key_value.get(), &key_string);
 381     dictionary_value.SetWithoutPathExpansion(
 382         key_string, new base::FundamentalValue(values[i]));
 383   }
 384
 385   // Pop a dictionary.
 386   dbus::MessageReader reader(response.get());
 387   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 388   ASSERT_TRUE(value.get() != NULL);
 389   EXPECT_TRUE(value->Equals(&dictionary_value));
 390 }
 391
 392 TEST(ValuesUtilTest, AppendBasicTypes) {
 393   const base::FundamentalValue kBoolValue(false);
 394   const base::FundamentalValue kIntegerValue(42);
 395   const base::FundamentalValue kDoubleValue(4.2);
 396   const base::StringValue kStringValue("string");
 397
 398   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 399   dbus::MessageWriter writer(response.get());
 400   AppendBasicTypeValueData(&writer, kBoolValue);
 401   AppendBasicTypeValueData(&writer, kIntegerValue);
 402   AppendBasicTypeValueData(&writer, kDoubleValue);
 403   AppendBasicTypeValueData(&writer, kStringValue);
 404
 405   dbus::MessageReader reader(response.get());
 406   scoped_ptr<base::Value> value;
 407   value.reset(dbus::PopDataAsValue(&reader));
 408   ASSERT_TRUE(value.get() != NULL);
 409   EXPECT_TRUE(value->Equals(&kBoolValue));
 410   value.reset(dbus::PopDataAsValue(&reader));
 411   ASSERT_TRUE(value.get() != NULL);
 412   EXPECT_TRUE(value->Equals(&kIntegerValue));
 413   value.reset(dbus::PopDataAsValue(&reader));
 414   ASSERT_TRUE(value.get() != NULL);
 415   EXPECT_TRUE(value->Equals(&kDoubleValue));
 416   value.reset(dbus::PopDataAsValue(&reader));
 417   ASSERT_TRUE(value.get() != NULL);
 418   EXPECT_TRUE(value->Equals(&kStringValue));
 419 }
 420
 421 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
 422   const base::FundamentalValue kBoolValue(false);
 423   const base::FundamentalValue kIntegerValue(42);
 424   const base::FundamentalValue kDoubleValue(4.2);
 425   const base::StringValue kStringValue("string");
 426
 427   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
 428   dbus::MessageWriter writer(response.get());
 429   AppendBasicTypeValueDataAsVariant(&writer, kBoolValue);
 430   AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue);
 431   AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue);
 432   AppendBasicTypeValueDataAsVariant(&writer, kStringValue);
 433
 434   dbus::MessageReader reader(response.get());
 435   scoped_ptr<base::Value> value;
 436   value.reset(dbus::PopDataAsValue(&reader));
 437   ASSERT_TRUE(value.get() != NULL);
 438   EXPECT_TRUE(value->Equals(&kBoolValue));
 439   value.reset(dbus::PopDataAsValue(&reader));
 440   ASSERT_TRUE(value.get() != NULL);
 441   EXPECT_TRUE(value->Equals(&kIntegerValue));
 442   value.reset(dbus::PopDataAsValue(&reader));
 443   ASSERT_TRUE(value.get() != NULL);
 444   EXPECT_TRUE(value->Equals(&kDoubleValue));
 445   value.reset(dbus::PopDataAsValue(&reader));
 446   ASSERT_TRUE(value.get() != NULL);
 447   EXPECT_TRUE(value->Equals(&kStringValue));
 448 }