JSON Schema Compiler supports Enums as types.

tools/json_schema_compiler/test/enums_unittest.cc

Index: tools/json_schema_compiler/test/enums_unittest.cc
diff --git a/tools/json_schema_compiler/test/enums_unittest.cc b/tools/json_schema_compiler/test/enums_unittest.cc
index 6037874c62370ce59cf2a5b251bb6732dd697556..b9fec70e0e3d40ff8a637bc9ba555b47795e053f 100644
--- a/tools/json_schema_compiler/test/enums_unittest.cc
+++ b/tools/json_schema_compiler/test/enums_unittest.cc
@@ -10,18 +10,46 @@ using namespace test::api::enums;
 
 TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) {
   {
-    scoped_ptr<EnumType> enum_type(new EnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("one"));
-    EXPECT_TRUE(EnumType::Populate(*value, enum_type.get()));
-    EXPECT_EQ(EnumType::TYPE_ONE, enum_type->type);
-    EXPECT_TRUE(value->Equals(enum_type->ToValue().get()));
+    EnumType enum_type;
+    DictionaryValue value;
+    value.Set("type", Value::CreateStringValue("one"));
+    EXPECT_TRUE(EnumType::Populate(value, &enum_type));
+    EXPECT_EQ(EnumType::TYPE_ONE, enum_type.type);
+    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
   }
   {
-    scoped_ptr<EnumType> enum_type(new EnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("invalid"));
-    EXPECT_FALSE(EnumType::Populate(*value, enum_type.get()));
+    EnumType enum_type;
+    DictionaryValue value;
+    value.Set("type", Value::CreateStringValue("invalid"));
+    EXPECT_FALSE(EnumType::Populate(value, &enum_type));
+  }
+}
+
+TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) {
+  {
+    ListValue args;
+    args.Append(Value::CreateStringValue("one"));
+
+    scoped_ptr<TakesEnumAsType::Params> params(
+        TakesEnumAsType::Params::Create(args));
+    ASSERT_TRUE(params.get());
+    EXPECT_EQ(ENUMERATION_ONE, params->enumeration);
+
+    EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create(
+        ENUMERATION_ONE).get()));
+  }
+  {
+    HasEnumeration enumeration;
+    DictionaryValue value;
+    ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration));
+
+    value.Set("enumeration", Value::CreateStringValue("one"));
+    ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
+    EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
+
+    value.Set("optional_enumeration", Value::CreateStringValue("two"));
+    ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
+    EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
   }
 }
 
@@ -55,105 +83,105 @@ TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) {
 
 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) {
   {
-    scoped_ptr<OptionalEnumType> enum_type(new OptionalEnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("two"));
-    EXPECT_TRUE(OptionalEnumType::Populate(*value, enum_type.get()));
-    EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type->type);
-    EXPECT_TRUE(value->Equals(enum_type->ToValue().get()));
+    OptionalEnumType enum_type;
+    DictionaryValue value;
+    value.Set("type", Value::CreateStringValue("two"));
+    EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
+    EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type.type);
+    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
   }
   {
-    scoped_ptr<OptionalEnumType> enum_type(new OptionalEnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    EXPECT_TRUE(OptionalEnumType::Populate(*value, enum_type.get()));
-    EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type->type);
-    EXPECT_TRUE(value->Equals(enum_type->ToValue().get()));
+    OptionalEnumType enum_type;
+    DictionaryValue value;
+    EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
+    EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type.type);
+    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
   }
   {
-    scoped_ptr<OptionalEnumType> enum_type(new OptionalEnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("invalid"));
-    EXPECT_FALSE(OptionalEnumType::Populate(*value, enum_type.get()));
+    OptionalEnumType enum_type;
+    DictionaryValue value;
+    value.Set("type", Value::CreateStringValue("invalid"));
+    EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type));
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) {
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("baz"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("baz"));
     scoped_ptr<TakesEnum::Params> params(
-        TakesEnum::Params::Create(*params_value));
+        TakesEnum::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesEnum::Params::STATE_BAZ, params->state);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("invalid"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("invalid"));
     scoped_ptr<TakesEnum::Params> params(
-        TakesEnum::Params::Create(*params_value));
+        TakesEnum::Params::Create(params_value));
     EXPECT_FALSE(params.get());
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) {
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("baz"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("baz"));
     scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(*params_value));
+        TakesOptionalEnum::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
+    ListValue params_value;
     scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(*params_value));
+        TakesOptionalEnum::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesOptionalEnum::Params::STATE_NONE, params->state);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("invalid"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("invalid"));
     scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(*params_value));
+        TakesOptionalEnum::Params::Create(params_value));
     EXPECT_FALSE(params.get());
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) {
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("foo"));
-    params_value->Append(Value::CreateStringValue("foo"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("foo"));
+    params_value.Append(Value::CreateStringValue("foo"));
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(*params_value));
+        TakesMultipleOptionalEnums::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state);
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_FOO, params->type);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("foo"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("foo"));
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(*params_value));
+        TakesMultipleOptionalEnums::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state);
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
+    ListValue params_value;
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(*params_value));
+        TakesMultipleOptionalEnums::Params::Create(params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_NONE, params->state);
     EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type);
   }
   {
-    scoped_ptr<ListValue> params_value(new ListValue());
-    params_value->Append(Value::CreateStringValue("baz"));
-    params_value->Append(Value::CreateStringValue("invalid"));
+    ListValue params_value;
+    params_value.Append(Value::CreateStringValue("baz"));
+    params_value.Append(Value::CreateStringValue("invalid"));
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(*params_value));
+        TakesMultipleOptionalEnums::Params::Create(params_value));
     EXPECT_FALSE(params.get());
   }
 }