values_util_unittest.cc revision 7d4cd473f85ac64c3747c96c277f9e506a0d2246 
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
16namespace dbus {
17
18TEST(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
115TEST(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.
155TEST(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
186TEST(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
212TEST(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
235TEST(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
265TEST(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
312TEST(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
355TEST(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
394TEST(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
423TEST(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}  // namespace dbus
453