You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
688 lines
24 KiB
688 lines
24 KiB
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "dbus/values_util.h"
|
|
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#include <cmath>
|
|
#include <memory>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "base/json/json_writer.h"
|
|
#include "base/macros.h"
|
|
#include "base/values.h"
|
|
#include "dbus/message.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace dbus {
|
|
|
|
TEST(ValuesUtilTest, PopBasicTypes) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append basic type values.
|
|
MessageWriter writer(response.get());
|
|
const uint8_t kByteValue = 42;
|
|
writer.AppendByte(kByteValue);
|
|
const bool kBoolValue = true;
|
|
writer.AppendBool(kBoolValue);
|
|
const int16_t kInt16Value = -43;
|
|
writer.AppendInt16(kInt16Value);
|
|
const uint16_t kUint16Value = 44;
|
|
writer.AppendUint16(kUint16Value);
|
|
const int32_t kInt32Value = -45;
|
|
writer.AppendInt32(kInt32Value);
|
|
const uint32_t kUint32Value = 46;
|
|
writer.AppendUint32(kUint32Value);
|
|
const int64_t kInt64Value = -47;
|
|
writer.AppendInt64(kInt64Value);
|
|
const uint64_t kUint64Value = 48;
|
|
writer.AppendUint64(kUint64Value);
|
|
const double kDoubleValue = 4.9;
|
|
writer.AppendDouble(kDoubleValue);
|
|
const std::string kStringValue = "fifty";
|
|
writer.AppendString(kStringValue);
|
|
const std::string kEmptyStringValue;
|
|
writer.AppendString(kEmptyStringValue);
|
|
const ObjectPath kObjectPathValue("/ObjectPath");
|
|
writer.AppendObjectPath(kObjectPathValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
std::unique_ptr<base::Value> expected_value;
|
|
// Pop a byte.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kByteValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a bool.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kBoolValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an int16_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kInt16Value));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a uint16_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kUint16Value));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an int32_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kInt32Value));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a uint32_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(static_cast<double>(kUint32Value)));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an int64_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a uint64_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a double.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kDoubleValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a string.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kStringValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an empty string.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kEmptyStringValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an object path.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kObjectPathValue.value()));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopVariant) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append variant values.
|
|
MessageWriter writer(response.get());
|
|
const bool kBoolValue = true;
|
|
writer.AppendVariantOfBool(kBoolValue);
|
|
const int32_t kInt32Value = -45;
|
|
writer.AppendVariantOfInt32(kInt32Value);
|
|
const double kDoubleValue = 4.9;
|
|
writer.AppendVariantOfDouble(kDoubleValue);
|
|
const std::string kStringValue = "fifty";
|
|
writer.AppendVariantOfString(kStringValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
std::unique_ptr<base::Value> expected_value;
|
|
// Pop a bool.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kBoolValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop an int32_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kInt32Value));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a double.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kDoubleValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
// Pop a string.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(kStringValue));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
}
|
|
|
|
// Pop extremely large integers which cannot be precisely represented in
|
|
// double.
|
|
TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append large integers.
|
|
MessageWriter writer(response.get());
|
|
const int64_t kInt64Value = -123456789012345689LL;
|
|
writer.AppendInt64(kInt64Value);
|
|
const uint64_t kUint64Value = 9876543210987654321ULL;
|
|
writer.AppendUint64(kUint64Value);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
std::unique_ptr<base::Value> expected_value;
|
|
double double_value = 0;
|
|
// Pop an int64_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
ASSERT_TRUE(value->GetAsDouble(&double_value));
|
|
EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value));
|
|
// Pop a uint64_t.
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
|
|
EXPECT_TRUE(value->Equals(expected_value.get()));
|
|
ASSERT_TRUE(value->GetAsDouble(&double_value));
|
|
EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopIntArray) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append an int32_t array.
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
std::vector<int32_t> data;
|
|
data.push_back(0);
|
|
data.push_back(1);
|
|
data.push_back(2);
|
|
writer.OpenArray("i", &sub_writer);
|
|
for (size_t i = 0; i != data.size(); ++i)
|
|
sub_writer.AppendInt32(data[i]);
|
|
writer.CloseContainer(&sub_writer);
|
|
|
|
// Create the expected value.
|
|
std::unique_ptr<base::ListValue> list_value(new base::ListValue);
|
|
for (size_t i = 0; i != data.size(); ++i)
|
|
list_value->AppendInteger(data[i]);
|
|
|
|
// Pop an int32_t array.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(list_value.get()));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopStringArray) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append a string array.
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
std::vector<std::string> data;
|
|
data.push_back("Dreamlifter");
|
|
data.push_back("Beluga");
|
|
data.push_back("Mriya");
|
|
writer.AppendArrayOfStrings(data);
|
|
|
|
// Create the expected value.
|
|
std::unique_ptr<base::ListValue> list_value(new base::ListValue);
|
|
for (size_t i = 0; i != data.size(); ++i)
|
|
list_value->AppendString(data[i]);
|
|
|
|
// Pop a string array.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(list_value.get()));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopStruct) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append a struct.
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
writer.OpenStruct(&sub_writer);
|
|
const bool kBoolValue = true;
|
|
sub_writer.AppendBool(kBoolValue);
|
|
const int32_t kInt32Value = -123;
|
|
sub_writer.AppendInt32(kInt32Value);
|
|
const double kDoubleValue = 1.23;
|
|
sub_writer.AppendDouble(kDoubleValue);
|
|
const std::string kStringValue = "one two three";
|
|
sub_writer.AppendString(kStringValue);
|
|
writer.CloseContainer(&sub_writer);
|
|
|
|
// Create the expected value.
|
|
base::ListValue list_value;
|
|
list_value.AppendBoolean(kBoolValue);
|
|
list_value.AppendInteger(kInt32Value);
|
|
list_value.AppendDouble(kDoubleValue);
|
|
list_value.AppendString(kStringValue);
|
|
|
|
// Pop a struct.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&list_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopStringToVariantDictionary) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append a dictionary.
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
MessageWriter entry_writer(nullptr);
|
|
writer.OpenArray("{sv}", &sub_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey1 = "one";
|
|
entry_writer.AppendString(kKey1);
|
|
const bool kBoolValue = true;
|
|
entry_writer.AppendVariantOfBool(kBoolValue);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey2 = "two";
|
|
entry_writer.AppendString(kKey2);
|
|
const int32_t kInt32Value = -45;
|
|
entry_writer.AppendVariantOfInt32(kInt32Value);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey3 = "three";
|
|
entry_writer.AppendString(kKey3);
|
|
const double kDoubleValue = 4.9;
|
|
entry_writer.AppendVariantOfDouble(kDoubleValue);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey4 = "four";
|
|
entry_writer.AppendString(kKey4);
|
|
const std::string kStringValue = "fifty";
|
|
entry_writer.AppendVariantOfString(kStringValue);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
writer.CloseContainer(&sub_writer);
|
|
|
|
// Create the expected value.
|
|
base::DictionaryValue dictionary_value;
|
|
dictionary_value.SetBoolean(kKey1, kBoolValue);
|
|
dictionary_value.SetInteger(kKey2, kInt32Value);
|
|
dictionary_value.SetDouble(kKey3, kDoubleValue);
|
|
dictionary_value.SetString(kKey4, kStringValue);
|
|
|
|
// Pop a dictinoary.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&dictionary_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) {
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
// Append a dictionary.
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
MessageWriter entry_writer(nullptr);
|
|
writer.OpenArray("{sv}", &sub_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey1 = "www.example.com"; // String including dots.
|
|
entry_writer.AppendString(kKey1);
|
|
const bool kBoolValue = true;
|
|
entry_writer.AppendVariantOfBool(kBoolValue);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey2 = ".example"; // String starting with a dot.
|
|
entry_writer.AppendString(kKey2);
|
|
const int32_t kInt32Value = -45;
|
|
entry_writer.AppendVariantOfInt32(kInt32Value);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
const std::string kKey3 = "example."; // String ending with a dot.
|
|
entry_writer.AppendString(kKey3);
|
|
const double kDoubleValue = 4.9;
|
|
entry_writer.AppendVariantOfDouble(kDoubleValue);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
writer.CloseContainer(&sub_writer);
|
|
|
|
// Create the expected value.
|
|
base::DictionaryValue dictionary_value;
|
|
dictionary_value.SetKey(kKey1, base::Value(kBoolValue));
|
|
dictionary_value.SetKey(kKey2, base::Value(kInt32Value));
|
|
dictionary_value.SetKey(kKey3, base::Value(kDoubleValue));
|
|
|
|
// Pop a dictinoary.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&dictionary_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
|
|
// Create test data.
|
|
const int32_t kValues[] = {0, 1, 1, 2, 3, 5, 8, 13, 21};
|
|
const std::vector<int32_t> values(kValues, kValues + arraysize(kValues));
|
|
std::vector<double> keys(values.size());
|
|
for (size_t i = 0; i != values.size(); ++i)
|
|
keys[i] = std::sqrt(values[i]);
|
|
|
|
// Append a dictionary.
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
MessageWriter sub_writer(nullptr);
|
|
writer.OpenArray("{di}", &sub_writer);
|
|
for (size_t i = 0; i != values.size(); ++i) {
|
|
MessageWriter entry_writer(nullptr);
|
|
sub_writer.OpenDictEntry(&entry_writer);
|
|
entry_writer.AppendDouble(keys[i]);
|
|
entry_writer.AppendInt32(values[i]);
|
|
sub_writer.CloseContainer(&entry_writer);
|
|
}
|
|
writer.CloseContainer(&sub_writer);
|
|
|
|
// Create the expected value.
|
|
base::DictionaryValue dictionary_value;
|
|
for (size_t i = 0; i != values.size(); ++i) {
|
|
std::string key_string;
|
|
base::JSONWriter::Write(base::Value(keys[i]), &key_string);
|
|
dictionary_value.SetKey(key_string, base::Value(values[i]));
|
|
}
|
|
|
|
// Pop a dictionary.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value(PopDataAsValue(&reader));
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&dictionary_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendBasicTypes) {
|
|
const base::Value kBoolValue(false);
|
|
const base::Value kIntegerValue(42);
|
|
const base::Value kDoubleValue(4.2);
|
|
const base::Value kStringValue("string");
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendBasicTypeValueData(&writer, kBoolValue);
|
|
AppendBasicTypeValueData(&writer, kIntegerValue);
|
|
AppendBasicTypeValueData(&writer, kDoubleValue);
|
|
AppendBasicTypeValueData(&writer, kStringValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kBoolValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kIntegerValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kDoubleValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kStringValue));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
|
|
const base::Value kBoolValue(false);
|
|
const base::Value kIntegerValue(42);
|
|
const base::Value kDoubleValue(4.2);
|
|
const base::Value kStringValue("string");
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendBasicTypeValueDataAsVariant(&writer, kBoolValue);
|
|
AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue);
|
|
AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue);
|
|
AppendBasicTypeValueDataAsVariant(&writer, kStringValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kBoolValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kIntegerValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kDoubleValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kStringValue));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
|
|
const base::Value kBoolValue(false);
|
|
const base::Value kIntegerValue(42);
|
|
const base::Value kDoubleValue(4.2);
|
|
const base::Value kStringValue("string");
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueData(&writer, kBoolValue);
|
|
AppendValueData(&writer, kIntegerValue);
|
|
AppendValueData(&writer, kDoubleValue);
|
|
AppendValueData(&writer, kStringValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kBoolValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kIntegerValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kDoubleValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kStringValue));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) {
|
|
const base::Value kBoolValue(false);
|
|
const base::Value kIntegerValue(42);
|
|
const base::Value kDoubleValue(4.2);
|
|
const base::Value kStringValue("string");
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueDataAsVariant(&writer, kBoolValue);
|
|
AppendValueDataAsVariant(&writer, kIntegerValue);
|
|
AppendValueDataAsVariant(&writer, kDoubleValue);
|
|
AppendValueDataAsVariant(&writer, kStringValue);
|
|
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kBoolValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kIntegerValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kDoubleValue));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&kStringValue));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendDictionary) {
|
|
// Set up the input dictionary.
|
|
const std::string kKey1 = "one";
|
|
const std::string kKey2 = "two";
|
|
const std::string kKey3 = "three";
|
|
const std::string kKey4 = "four";
|
|
const std::string kKey5 = "five";
|
|
const std::string kKey6 = "six";
|
|
|
|
const bool kBoolValue = true;
|
|
const int32_t kInt32Value = -45;
|
|
const double kDoubleValue = 4.9;
|
|
const std::string kStringValue = "fifty";
|
|
|
|
auto list_value = std::make_unique<base::ListValue>();
|
|
list_value->AppendBoolean(kBoolValue);
|
|
list_value->AppendInteger(kInt32Value);
|
|
|
|
auto dictionary_value = std::make_unique<base::DictionaryValue>();
|
|
dictionary_value->SetBoolean(kKey1, kBoolValue);
|
|
dictionary_value->SetInteger(kKey2, kDoubleValue);
|
|
|
|
base::DictionaryValue test_dictionary;
|
|
test_dictionary.SetBoolean(kKey1, kBoolValue);
|
|
test_dictionary.SetInteger(kKey2, kInt32Value);
|
|
test_dictionary.SetDouble(kKey3, kDoubleValue);
|
|
test_dictionary.SetString(kKey4, kStringValue);
|
|
test_dictionary.Set(kKey5, std::move(list_value));
|
|
test_dictionary.Set(kKey6, std::move(dictionary_value));
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueData(&writer, test_dictionary);
|
|
base::Value int_value(kInt32Value);
|
|
AppendValueData(&writer, int_value);
|
|
|
|
// Read the data.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&test_dictionary));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&int_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendDictionaryAsVariant) {
|
|
// Set up the input dictionary.
|
|
const std::string kKey1 = "one";
|
|
const std::string kKey2 = "two";
|
|
const std::string kKey3 = "three";
|
|
const std::string kKey4 = "four";
|
|
const std::string kKey5 = "five";
|
|
const std::string kKey6 = "six";
|
|
|
|
const bool kBoolValue = true;
|
|
const int32_t kInt32Value = -45;
|
|
const double kDoubleValue = 4.9;
|
|
const std::string kStringValue = "fifty";
|
|
|
|
auto list_value = std::make_unique<base::ListValue>();
|
|
list_value->AppendBoolean(kBoolValue);
|
|
list_value->AppendInteger(kInt32Value);
|
|
|
|
auto dictionary_value = std::make_unique<base::DictionaryValue>();
|
|
dictionary_value->SetBoolean(kKey1, kBoolValue);
|
|
dictionary_value->SetInteger(kKey2, kDoubleValue);
|
|
|
|
base::DictionaryValue test_dictionary;
|
|
test_dictionary.SetBoolean(kKey1, kBoolValue);
|
|
test_dictionary.SetInteger(kKey2, kInt32Value);
|
|
test_dictionary.SetDouble(kKey3, kDoubleValue);
|
|
test_dictionary.SetString(kKey4, kStringValue);
|
|
test_dictionary.Set(kKey5, std::move(list_value));
|
|
test_dictionary.Set(kKey6, std::move(dictionary_value));
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueDataAsVariant(&writer, test_dictionary);
|
|
base::Value int_value(kInt32Value);
|
|
AppendValueData(&writer, int_value);
|
|
|
|
// Read the data.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&test_dictionary));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&int_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendList) {
|
|
// Set up the input list.
|
|
const std::string kKey1 = "one";
|
|
const std::string kKey2 = "two";
|
|
|
|
const bool kBoolValue = true;
|
|
const int32_t kInt32Value = -45;
|
|
const double kDoubleValue = 4.9;
|
|
const std::string kStringValue = "fifty";
|
|
|
|
std::unique_ptr<base::ListValue> list_value(new base::ListValue());
|
|
list_value->AppendBoolean(kBoolValue);
|
|
list_value->AppendInteger(kInt32Value);
|
|
|
|
std::unique_ptr<base::DictionaryValue> dictionary_value(
|
|
new base::DictionaryValue());
|
|
dictionary_value->SetBoolean(kKey1, kBoolValue);
|
|
dictionary_value->SetInteger(kKey2, kDoubleValue);
|
|
|
|
base::ListValue test_list;
|
|
test_list.AppendBoolean(kBoolValue);
|
|
test_list.AppendInteger(kInt32Value);
|
|
test_list.AppendDouble(kDoubleValue);
|
|
test_list.AppendString(kStringValue);
|
|
test_list.Append(std::move(list_value));
|
|
test_list.Append(std::move(dictionary_value));
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueData(&writer, test_list);
|
|
base::Value int_value(kInt32Value);
|
|
AppendValueData(&writer, int_value);
|
|
|
|
// Read the data.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&test_list));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&int_value));
|
|
}
|
|
|
|
TEST(ValuesUtilTest, AppendListAsVariant) {
|
|
// Set up the input list.
|
|
const std::string kKey1 = "one";
|
|
const std::string kKey2 = "two";
|
|
|
|
const bool kBoolValue = true;
|
|
const int32_t kInt32Value = -45;
|
|
const double kDoubleValue = 4.9;
|
|
const std::string kStringValue = "fifty";
|
|
|
|
std::unique_ptr<base::ListValue> list_value(new base::ListValue());
|
|
list_value->AppendBoolean(kBoolValue);
|
|
list_value->AppendInteger(kInt32Value);
|
|
|
|
std::unique_ptr<base::DictionaryValue> dictionary_value(
|
|
new base::DictionaryValue());
|
|
dictionary_value->SetBoolean(kKey1, kBoolValue);
|
|
dictionary_value->SetInteger(kKey2, kDoubleValue);
|
|
|
|
base::ListValue test_list;
|
|
test_list.AppendBoolean(kBoolValue);
|
|
test_list.AppendInteger(kInt32Value);
|
|
test_list.AppendDouble(kDoubleValue);
|
|
test_list.AppendString(kStringValue);
|
|
test_list.Append(std::move(list_value));
|
|
test_list.Append(std::move(dictionary_value));
|
|
|
|
std::unique_ptr<Response> response(Response::CreateEmpty());
|
|
MessageWriter writer(response.get());
|
|
AppendValueDataAsVariant(&writer, test_list);
|
|
base::Value int_value(kInt32Value);
|
|
AppendValueData(&writer, int_value);
|
|
|
|
// Read the data.
|
|
MessageReader reader(response.get());
|
|
std::unique_ptr<base::Value> value;
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&test_list));
|
|
value = PopDataAsValue(&reader);
|
|
ASSERT_NE(nullptr, value);
|
|
EXPECT_TRUE(value->Equals(&int_value));
|
|
}
|
|
|
|
} // namespace dbus
|