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