buffet: Add Array type support for Buffet command and state props
Added definition of ArrayPropType and ArrayPropValue, added
parsing code to ObjectSchema to parse the array object type as well
as type detection code to detect array types from 'items', 'enum',
'default' properties of object schema definition.
Added a bunch of unit tests to verify that array definitions can
be parsed, values of type arrays can be constructuted and value
validation code works with arrays.
BUG=brillo:107
TEST=`FEATURES=test emerge-link buffet`
Change-Id: I0f7bbed012792e0a49fa1b071bb56fee512825a9
Reviewed-on: https://chromium-review.googlesource.com/261616
Reviewed-by: Vitaly Buka <vitalybuka@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Trybot-Ready: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/buffet/commands/object_schema.cc b/buffet/commands/object_schema.cc
index 5b565ed..96fe952 100644
--- a/buffet/commands/object_schema.cc
+++ b/buffet/commands/object_schema.cc
@@ -23,10 +23,24 @@
// Generates an error if the string identifies an unknown type.
std::unique_ptr<PropType> CreatePropType(const std::string& type_name,
chromeos::ErrorPtr* error) {
+ std::string primary_type;
+ std::string array_type;
+ chromeos::string_utils::SplitAtFirst(type_name, ".", &primary_type,
+ &array_type, false);
std::unique_ptr<PropType> prop;
ValueType type;
- if (PropType::GetTypeFromTypeString(type_name, &type))
+ if (PropType::GetTypeFromTypeString(primary_type, &type)) {
prop = PropType::Create(type);
+ if (prop && type == ValueType::Array && !array_type.empty()) {
+ auto items_type = CreatePropType(array_type, error);
+ if (items_type) {
+ prop->GetArray()->SetItemType(std::move(items_type));
+ } else {
+ prop.reset();
+ return prop;
+ }
+ }
+ }
if (!prop) {
chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
errors::commands::kUnknownType,
@@ -63,7 +77,8 @@
// to deduce the PropType from. Returns the string name of the type detected
// or empty string is type detection failed.
std::string DetectArrayType(const base::ListValue* list,
- const PropType* base_schema) {
+ const PropType* base_schema,
+ bool allow_arrays) {
std::string type_name;
if (base_schema) {
type_name = base_schema->GetTypeAsString();
@@ -86,6 +101,23 @@
case base::Value::TYPE_DICTIONARY:
type_name = PropType::GetTypeStringFromType(ValueType::Object);
break;
+ case base::Value::TYPE_LIST: {
+ if (allow_arrays) {
+ type_name = PropType::GetTypeStringFromType(ValueType::Array);
+ const base::ListValue* first_element_list = nullptr;
+ if (first_element->GetAsList(&first_element_list)) {
+ // We do not allow arrays of arrays.
+ auto child_type = DetectArrayType(first_element_list, nullptr,
+ false);
+ if (child_type.empty()) {
+ type_name.clear();
+ } else {
+ type_name += '.' + child_type;
+ }
+ }
+ }
+ break;
+ }
default:
// The rest are unsupported.
break;
@@ -105,7 +137,7 @@
std::unique_ptr<PropType> prop;
const base::ListValue* list = nullptr;
CHECK(value.GetAsList(&list)) << "Unable to get array value";
- std::string type_name = DetectArrayType(list, base_schema);
+ std::string type_name = DetectArrayType(list, base_schema, true);
if (type_name.empty()) {
ErrorInvalidTypeInfo(error);
return prop;
@@ -165,11 +197,15 @@
if (dict->HasKey(commands::attributes::kObject_Properties))
return PropType::GetTypeStringFromType(ValueType::Object);
+ // If we have "items", it's an array.
+ if (dict->HasKey(commands::attributes::kItems))
+ return PropType::GetTypeStringFromType(ValueType::Array);
+
// If we have "enum", it's an array. Detect type from array elements.
const base::ListValue* list = nullptr;
if (dict->GetListWithoutPathExpansion(
commands::attributes::kOneOf_Enum, &list))
- return DetectArrayType(list, base_schema);
+ return DetectArrayType(list, base_schema, true);
// If we have "default", try to use it for type detection.
if (dict->Get(commands::attributes::kDefault, &value)) {
@@ -181,9 +217,17 @@
return PropType::GetTypeStringFromType(ValueType::Boolean);
if (value->IsType(base::Value::TYPE_STRING))
return PropType::GetTypeStringFromType(ValueType::String);
+ if (value->IsType(base::Value::TYPE_LIST)) {
+ CHECK(value->GetAsList(&list)) << "List value expected";
+ std::string child_type = DetectArrayType(list, base_schema, false);
+ if (!child_type.empty()) {
+ return PropType::GetTypeStringFromType(ValueType::Array) + '.' +
+ child_type;
+ }
+ }
}
- return std::string();
+ return std::string{};
}
// Helper function for PropFromJson to handle the case of parameter being
diff --git a/buffet/commands/object_schema_unittest.cc b/buffet/commands/object_schema_unittest.cc
index f257a67..b0332d2 100644
--- a/buffet/commands/object_schema_unittest.cc
+++ b/buffet/commands/object_schema_unittest.cc
@@ -26,20 +26,25 @@
namespace {
template<typename T>
-std::vector<T> GetOneOfValues(const buffet::PropType* prop_type) {
+std::vector<T> GetArrayValues(const buffet::native_types::Array& arr) {
std::vector<T> values;
- auto one_of = static_cast<const buffet::ConstraintOneOf*>(
- prop_type->GetConstraint(buffet::ConstraintType::OneOf));
- if (!one_of)
- return values;
-
- values.reserve(one_of->set_.value.size());
- for (const auto& prop_value : one_of->set_.value) {
+ values.reserve(arr.size());
+ for (const auto& prop_value : arr) {
values.push_back(prop_value->GetValueAsAny().Get<T>());
}
return values;
}
+template<typename T>
+std::vector<T> GetOneOfValues(const buffet::PropType* prop_type) {
+ auto one_of = static_cast<const buffet::ConstraintOneOf*>(
+ prop_type->GetConstraint(buffet::ConstraintType::OneOf));
+ if (!one_of)
+ return {};
+
+ return GetArrayValues<T>(one_of->set_.value);
+}
+
} // anonymous namespace
TEST(CommandSchema, IntPropType_Empty) {
@@ -57,6 +62,7 @@
EXPECT_EQ(nullptr, prop.GetDouble());
EXPECT_EQ(nullptr, prop.GetString());
EXPECT_EQ(nullptr, prop.GetObject());
+ EXPECT_EQ(nullptr, prop.GetArray());
}
TEST(CommandSchema, IntPropType_ToJson) {
@@ -182,6 +188,7 @@
EXPECT_EQ(nullptr, prop.GetDouble());
EXPECT_EQ(nullptr, prop.GetString());
EXPECT_EQ(nullptr, prop.GetObject());
+ EXPECT_EQ(nullptr, prop.GetArray());
}
TEST(CommandSchema, BoolPropType_ToJson) {
@@ -274,6 +281,7 @@
EXPECT_EQ(&prop, prop.GetDouble());
EXPECT_EQ(nullptr, prop.GetString());
EXPECT_EQ(nullptr, prop.GetObject());
+ EXPECT_EQ(nullptr, prop.GetArray());
}
TEST(CommandSchema, DoublePropType_ToJson) {
@@ -396,6 +404,7 @@
EXPECT_EQ(nullptr, prop.GetDouble());
EXPECT_EQ(&prop, prop.GetString());
EXPECT_EQ(nullptr, prop.GetObject());
+ EXPECT_EQ(nullptr, prop.GetArray());
}
TEST(CommandSchema, StringPropType_ToJson) {
@@ -522,6 +531,7 @@
EXPECT_EQ(nullptr, prop.GetDouble());
EXPECT_EQ(nullptr, prop.GetString());
EXPECT_EQ(&prop, prop.GetObject());
+ EXPECT_EQ(nullptr, prop.GetArray());
}
TEST(CommandSchema, ObjectPropType_ToJson) {
@@ -669,6 +679,162 @@
///////////////////////////////////////////////////////////////////////////////
+TEST(CommandSchema, ArrayPropType_Empty) {
+ buffet::ArrayPropType prop;
+ EXPECT_FALSE(prop.HasOverriddenAttributes());
+ EXPECT_FALSE(prop.IsBasedOnSchema());
+ EXPECT_EQ(nullptr, prop.GetDefaultValue());
+ EXPECT_EQ(nullptr, prop.GetItemTypePtr());
+ prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+ EXPECT_TRUE(prop.HasOverriddenAttributes());
+ EXPECT_FALSE(prop.IsBasedOnSchema());
+ EXPECT_NE(nullptr, prop.GetItemTypePtr());
+}
+
+TEST(CommandSchema, ArrayPropType_Types) {
+ buffet::ArrayPropType prop;
+ EXPECT_EQ(nullptr, prop.GetInt());
+ EXPECT_EQ(nullptr, prop.GetBoolean());
+ EXPECT_EQ(nullptr, prop.GetDouble());
+ EXPECT_EQ(nullptr, prop.GetString());
+ EXPECT_EQ(nullptr, prop.GetObject());
+ EXPECT_EQ(&prop, prop.GetArray());
+}
+
+TEST(CommandSchema, ArrayPropType_ToJson) {
+ buffet::ArrayPropType prop;
+ prop.SetItemType(buffet::PropType::Create(buffet::ValueType::Int));
+ EXPECT_EQ("{'items':'integer'}",
+ ValueToString(prop.ToJson(false, nullptr).get()));
+ EXPECT_EQ("{'items':{'type':'integer'},'type':'array'}",
+ ValueToString(prop.ToJson(true, nullptr).get()));
+ EXPECT_FALSE(prop.IsBasedOnSchema());
+ buffet::ArrayPropType prop2;
+ prop2.FromJson(CreateDictionaryValue("{}").get(), &prop, nullptr);
+ EXPECT_EQ("{}", ValueToString(prop2.ToJson(false, nullptr).get()));
+ EXPECT_TRUE(prop2.IsBasedOnSchema());
+ prop2.FromJson(CreateDictionaryValue("{'default':[1,2,3]}").get(),
+ &prop, nullptr);
+ EXPECT_EQ("{'default':[1,2,3]}",
+ ValueToString(prop2.ToJson(false, nullptr).get()));
+ EXPECT_EQ("{'default':[1,2,3],'items':{'type':'integer'},'type':'array'}",
+ ValueToString(prop2.ToJson(true, nullptr).get()));
+}
+
+TEST(CommandSchema, ArrayPropType_FromJson) {
+ buffet::ArrayPropType prop;
+ EXPECT_TRUE(prop.FromJson(
+ CreateDictionaryValue("{'items':'integer'}").get(), nullptr, nullptr));
+ EXPECT_EQ(buffet::ValueType::Int, prop.GetItemTypePtr()->GetType());
+
+ buffet::ArrayPropType prop2;
+ ASSERT_TRUE(prop2.FromJson(CreateDictionaryValue(
+ "{'items':'string','default':['foo', 'bar', 'baz']}").get(), nullptr,
+ nullptr));
+ ASSERT_NE(nullptr, prop2.GetDefaultValue());
+ const buffet::ArrayValue* defval = prop2.GetDefaultValue()->GetArray();
+ ASSERT_NE(nullptr, defval);
+ EXPECT_EQ((std::vector<std::string>{"foo", "bar", "baz"}),
+ GetArrayValues<std::string>(defval->GetValue()));
+}
+
+TEST(CommandSchema, ArrayPropType_Validate) {
+ buffet::ArrayPropType prop;
+ prop.FromJson(CreateDictionaryValue(
+ "{'items':{'minimum':2.3, 'maximum':10.5}}").get(), nullptr,
+ nullptr);
+
+ chromeos::ErrorPtr error;
+ EXPECT_TRUE(prop.ValidateValue(CreateValue("[3,4,10.5]").get(), &error));
+ error.reset();
+
+ EXPECT_FALSE(prop.ValidateValue(CreateValue("[2]").get(), &error));
+ EXPECT_EQ("out_of_range", error->GetCode());
+ EXPECT_EQ("Value 2 is out of range. It must not be less than 2.3",
+ error->GetMessage());
+ error.reset();
+
+ EXPECT_FALSE(prop.ValidateValue(CreateValue("[4, 5, 20]").get(), &error));
+ EXPECT_EQ("out_of_range", error->GetCode());
+ EXPECT_EQ("Value 20 is out of range. It must not be greater than 10.5",
+ error->GetMessage());
+ error.reset();
+}
+
+TEST(CommandSchema, ArrayPropType_Validate_Enum) {
+ buffet::ArrayPropType prop;
+ prop.FromJson(CreateDictionaryValue(
+ "{'items':'integer', 'enum':[[1], [2,3], [4,5,6]]}").get(), nullptr,
+ nullptr);
+
+ chromeos::ErrorPtr error;
+ EXPECT_TRUE(prop.ValidateValue(CreateValue("[2,3]").get(), &error));
+ error.reset();
+
+ EXPECT_FALSE(prop.ValidateValue(CreateValue("[2]").get(), &error));
+ EXPECT_EQ("out_of_range", error->GetCode());
+ EXPECT_EQ("Value [2] is invalid. Expected one of [[1],[2,3],[4,5,6]]",
+ error->GetMessage());
+ error.reset();
+
+ EXPECT_FALSE(prop.ValidateValue(CreateValue("[2,3,4]").get(), &error));
+ EXPECT_EQ("out_of_range", error->GetCode());
+ error.reset();
+}
+
+TEST(CommandSchema, ArrayPropType_CreateValue) {
+ buffet::ArrayPropType prop;
+ ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(
+ "{'items':{'properties':{'width':'integer','height':'integer'}}}").get(),
+ nullptr, nullptr));
+
+ chromeos::ErrorPtr error;
+ buffet::native_types::Array arr;
+
+ auto val = prop.CreateValue(arr, &error);
+ ASSERT_NE(nullptr, val.get());
+ EXPECT_EQ(nullptr, error.get());
+ EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+ EXPECT_EQ("[]", ValueToString(val->ToJson(nullptr).get()));
+
+ buffet::IntPropType int_type;
+ buffet::ObjectPropType obj_type;
+ ASSERT_TRUE(obj_type.FromJson(CreateDictionaryValue(
+ "{'properties':{'width':'integer','height':'integer'}}").get(),
+ nullptr, nullptr));
+ arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
+ {"width", int_type.CreateValue(10, nullptr)},
+ {"height", int_type.CreateValue(20, nullptr)},
+ }, nullptr));
+ arr.push_back(obj_type.CreateValue(buffet::native_types::Object{
+ {"width", int_type.CreateValue(17, nullptr)},
+ {"height", int_type.CreateValue(18, nullptr)},
+ }, nullptr));
+
+ val = prop.CreateValue(arr, &error);
+ ASSERT_NE(nullptr, val.get());
+ EXPECT_EQ(nullptr, error.get());
+ EXPECT_EQ(arr, val->GetValueAsAny().Get<buffet::native_types::Array>());
+ EXPECT_EQ("[{'height':20,'width':10},{'height':18,'width':17}]",
+ ValueToString(val->ToJson(nullptr).get()));
+
+ val = prop.CreateValue("blah", &error);
+ EXPECT_EQ(nullptr, val.get());
+ ASSERT_NE(nullptr, error.get());
+ EXPECT_EQ(buffet::errors::commands::kTypeMismatch, error->GetCode());
+}
+
+TEST(CommandSchema, ArrayPropType_NestedArrays_NotSupported) {
+ buffet::ArrayPropType prop;
+ chromeos::ErrorPtr error;
+ EXPECT_FALSE(prop.FromJson(CreateDictionaryValue(
+ "{'items':{'items':'integer'}}").get(), nullptr, &error));
+ EXPECT_EQ(buffet::errors::commands::kInvalidObjectSchema, error->GetCode());
+ error.reset();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeName) {
buffet::ObjectSchema schema;
const char* schema_str = "{"
@@ -703,17 +869,23 @@
const char* schema_str = "{"
"'param1':{'type':'integer'},"
"'param2':{'type':'number'},"
- "'param3':{'type':'string'}"
+ "'param3':{'type':'string'},"
+ "'param4':{'type':'array', 'items':'integer'},"
+ "'param5':{'type':'object', 'properties':{'p1':'integer'}}"
"}";
EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
nullptr));
EXPECT_EQ(buffet::ValueType::Int, schema.GetProp("param1")->GetType());
EXPECT_EQ(buffet::ValueType::Double, schema.GetProp("param2")->GetType());
EXPECT_EQ(buffet::ValueType::String, schema.GetProp("param3")->GetType());
+ EXPECT_EQ(buffet::ValueType::Array, schema.GetProp("param4")->GetType());
+ EXPECT_EQ(buffet::ValueType::Object, schema.GetProp("param5")->GetType());
EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
EXPECT_EQ("number", schema.GetProp("param2")->GetTypeAsString());
EXPECT_EQ("string", schema.GetProp("param3")->GetTypeAsString());
- EXPECT_EQ(nullptr, schema.GetProp("param4"));
+ EXPECT_EQ("array", schema.GetProp("param4")->GetTypeAsString());
+ EXPECT_EQ("object", schema.GetProp("param5")->GetTypeAsString());
+ EXPECT_EQ(nullptr, schema.GetProp("param77"));
int min_int = (std::numeric_limits<int>::min)();
int max_int = (std::numeric_limits<int>::max)();
@@ -745,7 +917,9 @@
"'param13':{'default':13.5},"
"'param14':{'default':true},"
"'param15':{'default':false},"
- "'param16':{'default':'foobar'}"
+ "'param16':{'default':'foobar'},"
+ "'param17':{'default':[1,2,3]},"
+ "'param18':{'items':'number', 'default':[]}"
"}";
EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
nullptr));
@@ -765,6 +939,14 @@
EXPECT_EQ("boolean", schema.GetProp("param14")->GetTypeAsString());
EXPECT_EQ("boolean", schema.GetProp("param15")->GetTypeAsString());
EXPECT_EQ("string", schema.GetProp("param16")->GetTypeAsString());
+ EXPECT_EQ("array", schema.GetProp("param17")->GetTypeAsString());
+ auto prop17 = schema.GetProp("param17");
+ EXPECT_EQ("integer",
+ prop17->GetArray()->GetItemTypePtr()->GetTypeAsString());
+ EXPECT_EQ("array", schema.GetProp("param18")->GetTypeAsString());
+ auto prop18 = schema.GetProp("param18");
+ EXPECT_EQ("number",
+ prop18->GetArray()->GetItemTypePtr()->GetTypeAsString());
int min_int = (std::numeric_limits<int>::min)();
int max_int = (std::numeric_limits<int>::max)();
@@ -804,6 +986,11 @@
EXPECT_FALSE(val->GetBoolean()->GetValue());
val = schema.GetProp("param16")->GetDefaultValue();
EXPECT_EQ("foobar", val->GetString()->GetValue());
+ val = schema.GetProp("param17")->GetDefaultValue();
+ EXPECT_EQ((std::vector<int>{1, 2, 3}),
+ GetArrayValues<int>(val->GetArray()->GetValue()));
+ val = schema.GetProp("param18")->GetDefaultValue();
+ EXPECT_TRUE(val->GetArray()->GetValue().empty());
}
TEST(CommandSchema, ObjectSchema_FromJson_Shorthand_TypeDeduction_Array) {
@@ -818,8 +1005,11 @@
"'param7' :{'type':'integer', 'enum':[1,2,3]},"
"'param8' :{'type':'number', 'enum':[1,2,3]},"
"'param9' :{'type':'number', 'enum':[]},"
- "'param10':{'type':'integer', 'enum':[]}"
- "}";
+ "'param10':{'type':'integer', 'enum':[]},"
+ "'param11':[[0,1],[2,3]],"
+ "'param12':[['foo','bar']],"
+ "'param13':{'enum':[['id0', 'id1']]}"
+ "}";
EXPECT_TRUE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
nullptr));
EXPECT_EQ("integer", schema.GetProp("param1")->GetTypeAsString());
@@ -833,6 +1023,21 @@
EXPECT_EQ("number", schema.GetProp("param9")->GetTypeAsString());
EXPECT_EQ("integer", schema.GetProp("param10")->GetTypeAsString());
+ auto prop_type11 = schema.GetProp("param11");
+ EXPECT_EQ("array", prop_type11->GetTypeAsString());
+ EXPECT_EQ("integer",
+ prop_type11->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
+ auto prop_type12 = schema.GetProp("param12");
+ EXPECT_EQ("array", prop_type12->GetTypeAsString());
+ EXPECT_EQ("string",
+ prop_type12->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
+ auto prop_type13 = schema.GetProp("param13");
+ EXPECT_EQ("array", prop_type12->GetTypeAsString());
+ EXPECT_EQ("string",
+ prop_type13->GetArray()->GetItemTypePtr()->GetTypeAsString());
+
EXPECT_EQ((std::vector<int>{0, 1, 2, 3}),
GetOneOfValues<int>(schema.GetProp("param1")));
EXPECT_EQ((std::vector<double>{0.0, 1.1, 2.2}),
@@ -985,7 +1190,8 @@
"'param3':{'default':3.3},"
"'param4':{'default':'four'},"
"'param5':{'default':{'x':5,'y':6},"
- "'properties':{'x':'integer','y':'integer'}}"
+ "'properties':{'x':'integer','y':'integer'}},"
+ "'param6':{'default':[1,2,3]}"
"}}";
ASSERT_TRUE(prop.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
nullptr));
@@ -1001,6 +1207,8 @@
buffet::native_types::Object param5 = obj["param5"]->GetObject()->GetValue();
EXPECT_EQ(5, param5["x"]->GetInt()->GetValue());
EXPECT_EQ(6, param5["y"]->GetInt()->GetValue());
+ buffet::native_types::Array param6 = obj["param6"]->GetArray()->GetValue();
+ EXPECT_EQ((std::vector<int>{1, 2, 3}), GetArrayValues<int>(param6));
// Specify some.
value = prop.CreateValue();
@@ -1018,6 +1226,8 @@
param5 = obj["param5"]->GetObject()->GetValue();
EXPECT_EQ(-5, param5["x"]->GetInt()->GetValue());
EXPECT_EQ(-6, param5["y"]->GetInt()->GetValue());
+ param6 = obj["param6"]->GetArray()->GetValue();
+ EXPECT_EQ((std::vector<int>{1, 2, 3}), GetArrayValues<int>(param6));
// Specify all.
value = prop.CreateValue();
@@ -1026,7 +1236,8 @@
"'param2':22,"
"'param3':333.3,"
"'param4':'FOUR',"
- "'param5':{'x':-55,'y':66}"
+ "'param5':{'x':-55,'y':66},"
+ "'param6':[-1, 0]"
"}";
ASSERT_TRUE(value->FromJson(CreateDictionaryValue(val_json).get(), nullptr));
obj = value->GetObject()->GetValue();
@@ -1037,6 +1248,8 @@
param5 = obj["param5"]->GetObject()->GetValue();
EXPECT_EQ(-55, param5["x"]->GetInt()->GetValue());
EXPECT_EQ(66, param5["y"]->GetInt()->GetValue());
+ param6 = obj["param6"]->GetArray()->GetValue();
+ EXPECT_EQ((std::vector<int>{-1, 0}), GetArrayValues<int>(param6));
}
TEST(CommandSchema, ObjectSchema_FromJson_BaseSchema_Failures) {
@@ -1105,4 +1318,52 @@
&error));
EXPECT_EQ("out_of_range", error->GetFirstError()->GetCode());
error.reset();
+
+ schema_str = "{"
+ "'param1':[[1,2.3]]"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
+ error.reset();
+
+ schema_str = "{"
+ "'param1':[[1,2],[3,4],['blah']]"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("type_mismatch", error->GetFirstError()->GetCode());
+ error.reset();
+
+ schema_str = "{"
+ "'param1':{'default':[]}"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+ error.reset();
+
+ schema_str = "{"
+ "'param1':[[[1]],[[2]]]"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+ error.reset();
+
+ schema_str = "{"
+ "'param1':{'enum':[[['foo']]]}"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+ error.reset();
+
+ schema_str = "{"
+ "'param1':{'default':[[1],[2]]}"
+ "}";
+ EXPECT_FALSE(schema.FromJson(CreateDictionaryValue(schema_str).get(), nullptr,
+ &error));
+ EXPECT_EQ("no_type_info", error->GetFirstError()->GetCode());
+ error.reset();
}
diff --git a/buffet/commands/prop_constraints.cc b/buffet/commands/prop_constraints.cc
index 085fe26..f773290 100644
--- a/buffet/commands/prop_constraints.cc
+++ b/buffet/commands/prop_constraints.cc
@@ -160,9 +160,9 @@
}
// ConstraintOneOf --------------------------------------------------
-ConstraintOneOf::ConstraintOneOf(InheritableAttribute<ChoiceList> set)
+ConstraintOneOf::ConstraintOneOf(InheritableAttribute<native_types::Array> set)
: set_(std::move(set)) {}
-ConstraintOneOf::ConstraintOneOf(ChoiceList set)
+ConstraintOneOf::ConstraintOneOf(native_types::Array set)
: set_(std::move(set)) {}
bool ConstraintOneOf::Validate(const PropValue& value,
@@ -180,7 +180,7 @@
}
std::unique_ptr<Constraint> ConstraintOneOf::Clone() const {
- InheritableAttribute<ChoiceList> attr;
+ InheritableAttribute<native_types::Array> attr;
attr.is_inherited = set_.is_inherited;
attr.value.reserve(set_.value.size());
for (const auto& prop_value : set_.value) {
@@ -190,7 +190,7 @@
}
std::unique_ptr<Constraint> ConstraintOneOf::CloneAsInherited() const {
- ChoiceList cloned;
+ native_types::Array cloned;
cloned.reserve(set_.value.size());
for (const auto& prop_value : set_.value) {
cloned.push_back(prop_value->Clone());
@@ -200,14 +200,7 @@
std::unique_ptr<base::Value> ConstraintOneOf::ToJson(
chromeos::ErrorPtr* error) const {
- std::unique_ptr<base::ListValue> list(new base::ListValue);
- for (const auto& prop_value : set_.value) {
- auto json = prop_value->ToJson(error);
- if (!json)
- return std::unique_ptr<base::Value>();
- list->Append(json.release());
- }
- return std::move(list);
+ return TypedValueToJson(set_.value, error);
}
const char* ConstraintOneOf::GetDictKey() const {
diff --git a/buffet/commands/prop_constraints.h b/buffet/commands/prop_constraints.h
index e5efdd2..c6b7e9b 100644
--- a/buffet/commands/prop_constraints.h
+++ b/buffet/commands/prop_constraints.h
@@ -297,10 +297,8 @@
// Implementation of OneOf constraint for different data types.
class ConstraintOneOf : public Constraint {
public:
- using ChoiceList = std::vector<std::unique_ptr<const PropValue>>;
-
- explicit ConstraintOneOf(InheritableAttribute<ChoiceList> set);
- explicit ConstraintOneOf(ChoiceList set);
+ explicit ConstraintOneOf(InheritableAttribute<native_types::Array> set);
+ explicit ConstraintOneOf(native_types::Array set);
// Implementation of Constraint::GetType().
ConstraintType GetType() const override {
@@ -331,7 +329,7 @@
// Stores the list of acceptable values for the parameter.
// |set_.is_inherited| indicates whether the constraint is inherited
// from base schema or overridden.
- InheritableAttribute<ChoiceList> set_;
+ InheritableAttribute<native_types::Array> set_;
private:
DISALLOW_COPY_AND_ASSIGN(ConstraintOneOf);
diff --git a/buffet/commands/prop_types.cc b/buffet/commands/prop_types.cc
index 3bb0577..a31f135 100644
--- a/buffet/commands/prop_types.cc
+++ b/buffet/commands/prop_types.cc
@@ -231,6 +231,7 @@
{ValueType::String, "string"},
{ValueType::Boolean, "boolean"},
{ValueType::Object, "object"},
+ {ValueType::Array, "array"},
};
return map;
}
@@ -272,6 +273,9 @@
case buffet::ValueType::Object:
prop = new ObjectPropType;
break;
+ case buffet::ValueType::Array:
+ prop = new ArrayPropType;
+ break;
}
return std::unique_ptr<PropType>(prop);
}
@@ -290,24 +294,15 @@
const PropType* prop_type,
chromeos::ErrorPtr* error) {
std::unique_ptr<Constraint> constraint;
- const base::ListValue* list = nullptr;
- if (!value->GetListWithoutPathExpansion(commands::attributes::kOneOf_Enum,
- &list)) {
- chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
- errors::commands::kTypeMismatch,
- "Expecting an array");
+ const base::Value* list = nullptr; // Owned by |value|
+ CHECK(value->Get(commands::attributes::kOneOf_Enum, &list))
+ << "'enum' property missing in JSON dictionary";
+ native_types::Array choice_list;
+ ArrayPropType array_type;
+ array_type.SetItemType(prop_type->Clone());
+ if (!TypedValueFromJson(list, &array_type, &choice_list, error))
return constraint;
- }
- ConstraintOneOf::ChoiceList choice_list;
- choice_list.reserve(list->GetSize());
- for (const base::Value* item : *list) {
- std::unique_ptr<PropValue> prop_value = prop_type->CreateValue();
- if (!prop_value->FromJson(item, error))
- return constraint;
- choice_list.push_back(std::move(prop_value));
- }
- InheritableAttribute<ConstraintOneOf::ChoiceList> val(std::move(choice_list),
- false);
+ InheritableAttribute<native_types::Array> val(std::move(choice_list), false);
constraint.reset(new ConstraintOneOf{std::move(val)});
return constraint;
}
@@ -362,7 +357,7 @@
const base::DictionaryValue* value,
std::set<std::string>* processed_keys,
chromeos::ErrorPtr* error) {
- if (!_Base::ConstraintsFromJson(value, processed_keys, error))
+ if (!Base::ConstraintsFromJson(value, processed_keys, error))
return false;
if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
@@ -398,7 +393,7 @@
const base::DictionaryValue* value,
std::set<std::string>* processed_keys,
chromeos::ErrorPtr* error) {
- if (!_Base::ConstraintsFromJson(value, processed_keys, error))
+ if (!Base::ConstraintsFromJson(value, processed_keys, error))
return false;
if (processed_keys->find(commands::attributes::kOneOf_Enum) ==
@@ -459,7 +454,7 @@
}
std::unique_ptr<PropType> ObjectPropType::Clone() const {
- auto cloned = _Base::Clone();
+ auto cloned = Base::Clone();
cloned->GetObject()->object_schema_.is_inherited =
object_schema_.is_inherited;
@@ -490,7 +485,7 @@
const PropType* base_schema,
std::set<std::string>* processed_keys,
chromeos::ErrorPtr* error) {
- if (!_Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
+ if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
return false;
using commands::attributes::kObject_Properties;
@@ -532,4 +527,87 @@
object_schema_.is_inherited = false;
}
+// ArrayPropType -------------------------------------------------------------
+
+ArrayPropType::ArrayPropType() {}
+
+bool ArrayPropType::HasOverriddenAttributes() const {
+ return PropType::HasOverriddenAttributes() ||
+ !item_type_.is_inherited;
+}
+
+std::unique_ptr<PropType> ArrayPropType::Clone() const {
+ auto cloned = Base::Clone();
+
+ cloned->GetArray()->item_type_.is_inherited = item_type_.is_inherited;
+ cloned->GetArray()->item_type_.value = item_type_.value->Clone();
+ return cloned;
+}
+
+std::unique_ptr<base::Value> ArrayPropType::ToJson(
+ bool full_schema, chromeos::ErrorPtr* error) const {
+ std::unique_ptr<base::Value> value = PropType::ToJson(full_schema, error);
+ if (value) {
+ base::DictionaryValue* dict = nullptr;
+ CHECK(value->GetAsDictionary(&dict)) << "Expecting a JSON object";
+ if (!item_type_.is_inherited || full_schema) {
+ auto type = item_type_.value->ToJson(full_schema, error);
+ if (!type) {
+ value.reset();
+ return value;
+ }
+ dict->SetWithoutPathExpansion(commands::attributes::kItems,
+ type.release());
+ }
+ }
+ return value;
+}
+
+bool ArrayPropType::ObjectSchemaFromJson(const base::DictionaryValue* value,
+ const PropType* base_schema,
+ std::set<std::string>* processed_keys,
+ chromeos::ErrorPtr* error) {
+ if (!Base::ObjectSchemaFromJson(value, base_schema, processed_keys, error))
+ return false;
+
+ using commands::attributes::kItems;
+
+ const PropType* base_type = nullptr;
+ if (base_schema)
+ base_type = base_schema->GetArray()->GetItemTypePtr();
+
+ const base::Value* type_value = nullptr;
+ if (value->GetWithoutPathExpansion(kItems, &type_value)) {
+ processed_keys->insert(kItems);
+ auto item_type = ObjectSchema::PropFromJson(*type_value, base_type, error);
+ if (!item_type)
+ return false;
+ if (item_type->GetType() == ValueType::Array) {
+ chromeos::Error::AddTo(error, FROM_HERE, errors::commands::kDomain,
+ errors::commands::kInvalidObjectSchema,
+ "Arrays of arrays are not supported");
+ return false;
+ }
+ SetItemType(std::move(item_type));
+ } else if (!item_type_.value) {
+ if (base_type) {
+ item_type_.value = base_type->Clone();
+ item_type_.is_inherited = true;
+ } else {
+ chromeos::Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
+ errors::commands::kInvalidObjectSchema,
+ "Array type definition must include the "
+ "array item type ('%s' field not found)",
+ kItems);
+ return false;
+ }
+ }
+ return true;
+}
+
+void ArrayPropType::SetItemType(std::unique_ptr<const PropType> item_type) {
+ item_type_.value = std::move(item_type);
+ item_type_.is_inherited = false;
+}
+
} // namespace buffet
diff --git a/buffet/commands/prop_types.h b/buffet/commands/prop_types.h
index 1af057c..10ca853 100644
--- a/buffet/commands/prop_types.h
+++ b/buffet/commands/prop_types.h
@@ -26,6 +26,7 @@
class StringPropType;
class BooleanPropType;
class ObjectPropType;
+class ArrayPropType;
// PropType is a base class for all parameter type definition objects.
// Property definitions of a particular type will derive from this class and
@@ -76,6 +77,8 @@
virtual BooleanPropType const* GetBoolean() const { return nullptr; }
virtual ObjectPropType* GetObject() { return nullptr; }
virtual ObjectPropType const* GetObject() const { return nullptr; }
+ virtual ArrayPropType* GetArray() { return nullptr; }
+ virtual ArrayPropType const* GetArray() const { return nullptr; }
// Makes a full copy of this type definition.
virtual std::unique_ptr<PropType> Clone() const;
@@ -206,7 +209,7 @@
template<class Derived, class Value, typename T>
class NumericPropTypeBase : public PropTypeBase<Derived, Value, T> {
public:
- using _Base = PropTypeBase<Derived, Value, T>;
+ using Base = PropTypeBase<Derived, Value, T>;
bool ConstraintsFromJson(const base::DictionaryValue* value,
std::set<std::string>* processed_keys,
chromeos::ErrorPtr* error) override;
@@ -254,7 +257,7 @@
class StringPropType
: public PropTypeBase<StringPropType, StringValue, std::string> {
public:
- using _Base = PropTypeBase<StringPropType, StringValue, std::string>;
+ using Base = PropTypeBase<StringPropType, StringValue, std::string>;
// Overrides from the PropType base class.
StringPropType* GetString() override { return this; }
StringPropType const* GetString() const override { return this; }
@@ -283,7 +286,7 @@
class ObjectPropType
: public PropTypeBase<ObjectPropType, ObjectValue, native_types::Object> {
public:
- using _Base = PropTypeBase<ObjectPropType, ObjectValue, native_types::Object>;
+ using Base = PropTypeBase<ObjectPropType, ObjectValue, native_types::Object>;
ObjectPropType();
// Overrides from the ParamType base class.
@@ -310,6 +313,40 @@
private:
InheritableAttribute<std::unique_ptr<const ObjectSchema>> object_schema_;
};
+
+// Parameter definition of Array type.
+class ArrayPropType
+ : public PropTypeBase<ArrayPropType, ArrayValue, native_types::Array> {
+ public:
+ using Base = PropTypeBase<ArrayPropType, ArrayValue, native_types::Array>;
+ ArrayPropType();
+
+ // Overrides from the ParamType base class.
+ bool HasOverriddenAttributes() const override;
+
+ ArrayPropType* GetArray() override { return this; }
+ ArrayPropType const* GetArray() const override { return this; }
+
+ std::unique_ptr<PropType> Clone() const override;
+
+ std::unique_ptr<base::Value> ToJson(bool full_schema,
+ chromeos::ErrorPtr* error) const override;
+
+ bool ObjectSchemaFromJson(const base::DictionaryValue* value,
+ const PropType* base_schema,
+ std::set<std::string>* processed_keys,
+ chromeos::ErrorPtr* error) override;
+
+ // Returns a type for Array elements.
+ inline const PropType* GetItemTypePtr() const {
+ return item_type_.value.get();
+ }
+ void SetItemType(std::unique_ptr<const PropType> item_type);
+
+ private:
+ InheritableAttribute<std::unique_ptr<const PropType>> item_type_;
+};
+
} // namespace buffet
#endif // BUFFET_COMMANDS_PROP_TYPES_H_
diff --git a/buffet/commands/prop_values.h b/buffet/commands/prop_values.h
index 6f85a0c..228316f 100644
--- a/buffet/commands/prop_values.h
+++ b/buffet/commands/prop_values.h
@@ -27,7 +27,8 @@
Double,
String,
Boolean,
- Object
+ Object,
+ Array,
};
class PropValue;
@@ -36,6 +37,7 @@
class StringValue;
class BooleanValue;
class ObjectValue;
+class ArrayValue;
class PropType;
@@ -56,6 +58,10 @@
inline ValueType GetValueType<native_types::Object>() {
return ValueType::Object;
}
+template<>
+inline ValueType GetValueType<native_types::Array>() {
+ return ValueType::Array;
+}
// The base class for property values.
// Concrete value classes of various types will be derived from this base.
@@ -91,6 +97,8 @@
virtual BooleanValue const* GetBoolean() const { return nullptr; }
virtual ObjectValue* GetObject() { return nullptr; }
virtual ObjectValue const* GetObject() const { return nullptr; }
+ virtual ArrayValue* GetArray() { return nullptr; }
+ virtual ArrayValue const* GetArray() const { return nullptr; }
// Makes a full copy of this value class.
virtual std::unique_ptr<PropValue> Clone() const = 0;
@@ -118,14 +126,13 @@
std::unique_ptr<const PropType> type_;
};
-// A helper template base class for implementing simple (non-Object) value
-// classes.
+// A helper template base class for implementing value classes.
template<typename Derived, typename T>
class TypedValueBase : public PropValue {
public:
- // To help refer to this base class from derived classes, define _Base to
+ // To help refer to this base class from derived classes, define Base to
// be this class.
- using _Base = TypedValueBase<Derived, T>;
+ using Base = TypedValueBase<Derived, T>;
// Expose the non-default constructor of the base class.
using PropValue::PropValue;
@@ -150,7 +157,7 @@
bool IsEqual(const PropValue* value) const override {
if (GetType() != value->GetType())
return false;
- const _Base* value_base = static_cast<const _Base*>(value);
+ const Base* value_base = static_cast<const Base*>(value);
return CompareValue(GetValue(), value_base->GetValue());
}
@@ -166,7 +173,7 @@
// Value of type Integer.
class IntValue final : public TypedValueBase<IntValue, int> {
public:
- using _Base::_Base; // Expose the custom constructor of the base class.
+ using Base::Base; // Expose the custom constructor of the base class.
IntValue* GetInt() override { return this; }
IntValue const* GetInt() const override { return this; }
};
@@ -174,7 +181,7 @@
// Value of type Number.
class DoubleValue final : public TypedValueBase<DoubleValue, double> {
public:
- using _Base::_Base; // Expose the custom constructor of the base class.
+ using Base::Base; // Expose the custom constructor of the base class.
DoubleValue* GetDouble() override { return this; }
DoubleValue const* GetDouble() const override { return this; }
};
@@ -182,7 +189,7 @@
// Value of type String.
class StringValue final : public TypedValueBase<StringValue, std::string> {
public:
- using _Base::_Base; // Expose the custom constructor of the base class.
+ using Base::Base; // Expose the custom constructor of the base class.
StringValue* GetString() override { return this; }
StringValue const* GetString() const override { return this; }
};
@@ -190,7 +197,7 @@
// Value of type Boolean.
class BooleanValue final : public TypedValueBase<BooleanValue, bool> {
public:
- using _Base::_Base; // Expose the custom constructor of the base class.
+ using Base::Base; // Expose the custom constructor of the base class.
BooleanValue* GetBoolean() override { return this; }
BooleanValue const* GetBoolean() const override { return this; }
};
@@ -199,10 +206,20 @@
class ObjectValue final
: public TypedValueBase<ObjectValue, native_types::Object> {
public:
- using _Base::_Base; // Expose the custom constructor of the base class.
+ using Base::Base; // Expose the custom constructor of the base class.
ObjectValue* GetObject() override { return this; }
ObjectValue const* GetObject() const override { return this; }
};
+
+// Value of type Array.
+class ArrayValue final
+ : public TypedValueBase<ArrayValue, native_types::Array> {
+ public:
+ using Base::Base; // Expose the custom constructor of the base class.
+ ArrayValue* GetArray() override { return this; }
+ ArrayValue const* GetArray() const override { return this; }
+};
+
} // namespace buffet
#endif // BUFFET_COMMANDS_PROP_VALUES_H_
diff --git a/buffet/commands/schema_constants.cc b/buffet/commands/schema_constants.cc
index 22a4766..12cc6b6 100644
--- a/buffet/commands/schema_constants.cc
+++ b/buffet/commands/schema_constants.cc
@@ -31,6 +31,7 @@
const char kType[] = "type";
const char kDisplayName[] = "displayName";
const char kDefault[] = "default";
+const char kItems[] = "items";
const char kNumeric_Min[] = "minimum";
const char kNumeric_Max[] = "maximum";
@@ -40,7 +41,6 @@
const char kOneOf_Enum[] = "enum";
const char kOneOf_Metadata[] = "metadata";
-const char kOneOf_MetaSchema[] = "schema";
const char kObject_Properties[] = "properties";
diff --git a/buffet/commands/schema_constants.h b/buffet/commands/schema_constants.h
index 1cfbc75..a686271 100644
--- a/buffet/commands/schema_constants.h
+++ b/buffet/commands/schema_constants.h
@@ -35,6 +35,7 @@
extern const char kType[];
extern const char kDisplayName[];
extern const char kDefault[];
+extern const char kItems[];
extern const char kNumeric_Min[];
extern const char kNumeric_Max[];
@@ -44,7 +45,6 @@
extern const char kOneOf_Enum[];
extern const char kOneOf_Metadata[];
-extern const char kOneOf_MetaSchema[];
extern const char kObject_Properties[];
diff --git a/buffet/commands/schema_utils.cc b/buffet/commands/schema_utils.cc
index 47516eb..10e9797 100644
--- a/buffet/commands/schema_utils.cc
+++ b/buffet/commands/schema_utils.cc
@@ -81,6 +81,18 @@
return std::move(dict);
}
+std::unique_ptr<base::Value> TypedValueToJson(const native_types::Array& value,
+ chromeos::ErrorPtr* error) {
+ std::unique_ptr<base::ListValue> list(new base::ListValue);
+ for (const auto& item : value) {
+ auto json = item->ToJson(error);
+ if (!json)
+ return std::unique_ptr<base::Value>();
+ list->Append(json.release());
+ }
+ return std::move(list);
+}
+
bool TypedValueFromJson(const base::Value* value_in,
const PropType* type,
bool* value_out,
@@ -133,7 +145,8 @@
const base::Value* param_value = nullptr;
CHECK(dict->GetWithoutPathExpansion(pair.first, ¶m_value))
<< "Unable to get parameter";
- if (!value->FromJson(param_value, error)) {
+ if (!value->FromJson(param_value, error) ||
+ !pair.second->ValidateValue(value->GetValueAsAny(), error)) {
chromeos::Error::AddToPrintf(error, FROM_HERE,
errors::commands::kDomain,
errors::commands::kInvalidPropValue,
@@ -181,6 +194,31 @@
return true;
}
+bool TypedValueFromJson(const base::Value* value_in,
+ const PropType* type,
+ native_types::Array* value_out,
+ chromeos::ErrorPtr* error) {
+ const base::ListValue* list = nullptr;
+ if (!value_in->GetAsList(&list))
+ return ReportUnexpectedJson(value_in, value_out, error);
+
+ CHECK(type) << "Array type definition must be provided";
+ CHECK(ValueType::Array == type->GetType()) << "Type must be Array";
+ const PropType* item_type = type->GetArray()->GetItemTypePtr();
+ CHECK(item_type) << "Incomplete array type definition";
+
+ value_out->reserve(list->GetSize());
+ for (const base::Value* item : *list) {
+ std::unique_ptr<PropValue> prop_value = item_type->CreateValue();
+ if (!prop_value->FromJson(item, error) ||
+ !item_type->ValidateValue(prop_value->GetValueAsAny(), error)) {
+ return false;
+ }
+ value_out->push_back(std::move(prop_value));
+ }
+ return true;
+}
+
// Compares two sets of key-value pairs from two Objects.
static bool obj_cmp(const native_types::Object::value_type& v1,
const native_types::Object::value_type& v2) {
@@ -196,6 +234,20 @@
return pair == std::make_pair(obj1.end(), obj2.end());
}
+bool operator==(const native_types::Array& arr1,
+ const native_types::Array& arr2) {
+ if (arr1.size() != arr2.size())
+ return false;
+
+ using Type = const native_types::Array::value_type;
+ // Compare two array items.
+ auto arr_cmp = [](const Type& v1, const Type& v2) {
+ return v1->IsEqual(v2.get());
+ };
+ auto pair = std::mismatch(arr1.begin(), arr1.end(), arr2.begin(), arr_cmp);
+ return pair == std::make_pair(arr1.end(), arr2.end());
+}
+
std::string ToString(const native_types::Object& obj) {
auto val = TypedValueToJson(obj, nullptr);
std::string str;
@@ -203,6 +255,13 @@
return str;
}
+std::string ToString(const native_types::Array& arr) {
+ auto val = TypedValueToJson(arr, nullptr);
+ std::string str;
+ base::JSONWriter::Write(val.get(), &str);
+ return str;
+}
+
chromeos::Any PropValueToDBusVariant(const PropValue* value) {
if (value->GetType() != ValueType::Object)
return value->GetValueAsAny();
diff --git a/buffet/commands/schema_utils.h b/buffet/commands/schema_utils.h
index 5709ebc..625b854 100644
--- a/buffet/commands/schema_utils.h
+++ b/buffet/commands/schema_utils.h
@@ -27,10 +27,16 @@
namespace native_types {
// C++ representation of object values.
using Object = std::map<std::string, std::shared_ptr<const PropValue>>;
+// C++ representation of array of values.
+using Array = std::vector<std::shared_ptr<const PropValue>>;
} // namespace native_types
+
// Converts an object to string.
std::string ToString(const native_types::Object& obj);
+// Converts an array to string.
+std::string ToString(const native_types::Array& arr);
+
// InheritableAttribute class is used for specifying various command parameter
// attributes that can be inherited from a base (parent) schema.
// The |value| still specifies the actual attribute values, whether it
@@ -61,6 +67,8 @@
chromeos::ErrorPtr* error);
std::unique_ptr<base::Value> TypedValueToJson(const native_types::Object& value,
chromeos::ErrorPtr* error);
+std::unique_ptr<base::Value> TypedValueToJson(const native_types::Array& value,
+ chromeos::ErrorPtr* error);
template<typename T>
std::unique_ptr<base::Value> TypedValueToJson(const std::vector<T>& values,
chromeos::ErrorPtr* error) {
@@ -97,9 +105,15 @@
const PropType* type,
native_types::Object* value_out,
chromeos::ErrorPtr* error);
+bool TypedValueFromJson(const base::Value* value_in,
+ const PropType* type,
+ native_types::Array* value_out,
+ chromeos::ErrorPtr* error);
bool operator==(const native_types::Object& obj1,
const native_types::Object& obj2);
+bool operator==(const native_types::Array& arr1,
+ const native_types::Array& arr2);
// CompareValue is a helper function to help with implementing EqualsTo operator
// for various data types. For most scalar types it is using operator==(),
diff --git a/buffet/commands/schema_utils_unittest.cc b/buffet/commands/schema_utils_unittest.cc
index 4f9eabe..25fa553 100644
--- a/buffet/commands/schema_utils_unittest.cc
+++ b/buffet/commands/schema_utils_unittest.cc
@@ -67,6 +67,16 @@
ValueToString(buffet::TypedValueToJson(object, nullptr).get()));
}
+TEST(CommandSchemaUtils, TypedValueToJson_Array) {
+ buffet::IntPropType int_type;
+ buffet::native_types::Array arr;
+
+ arr.push_back(int_type.CreateValue(640, nullptr));
+ arr.push_back(int_type.CreateValue(480, nullptr));
+ EXPECT_EQ("[640,480]",
+ ValueToString(buffet::TypedValueToJson(arr, nullptr).get()));
+}
+
TEST(CommandSchemaUtils, TypedValueFromJson_Bool) {
bool value;
@@ -187,6 +197,27 @@
error.reset();
}
+TEST(CommandSchemaUtils, TypedValueFromJson_Array) {
+ buffet::native_types::Array arr;
+ buffet::StringPropType str_type;
+ str_type.AddLengthConstraint(3, 100);
+ buffet::ArrayPropType type;
+ type.SetItemType(str_type.Clone());
+
+ EXPECT_TRUE(buffet::TypedValueFromJson(
+ CreateValue("['foo', 'bar']").get(), &type, &arr, nullptr));
+ buffet::native_types::Array arr2;
+ arr2.push_back(str_type.CreateValue(std::string{"foo"}, nullptr));
+ arr2.push_back(str_type.CreateValue(std::string{"bar"}, nullptr));
+ EXPECT_EQ(arr2, arr);
+
+ chromeos::ErrorPtr error;
+ EXPECT_FALSE(buffet::TypedValueFromJson(
+ CreateValue("['baz', 'ab']").get(), &type, &arr, &error));
+ EXPECT_EQ(buffet::errors::commands::kOutOfRange, error->GetCode());
+ error.reset();
+}
+
TEST(CommandSchemaUtils, PropValueToDBusVariant) {
buffet::IntPropType int_type;
auto prop_value = int_type.CreateValue(5, nullptr);
