JSON Schema Compiler: Added event compilation.

tools/json_schema_compiler/test/enums_unittest.cc

 // 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 "tools/json_schema_compiler/test/enums.h"
 
+#include "chrome/common/extensions/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace test::api::enums;
+using namespace extensions;
 
 TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) {
   {
     scoped_ptr<EnumType> enum_type(new EnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("one"));
+    scoped_ptr<DictionaryValue> value(
+        DictionaryBuilder().Set("type", "one").Build());
     EXPECT_TRUE(EnumType::Populate(*value, enum_type.get()));
     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"));
+    scoped_ptr<DictionaryValue> value(
+        DictionaryBuilder().Set("type", "invalid").Build());
     EXPECT_FALSE(EnumType::Populate(*value, enum_type.get()));
   }
 }
 
+TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) {
+  {
+    ReturnsEnum::Result::State state = ReturnsEnum::Result::STATE_FOO;
+    scoped_ptr<Value> result(ReturnsEnum::Result::CreateEnumValue(state));
+    scoped_ptr<Value> expected(Value::CreateStringValue("foo"));
+    EXPECT_TRUE(result->Equals(expected.get()));
+  }
+  {
+    ReturnsEnum::Result::State state = ReturnsEnum::Result::STATE_FOO;
+    scoped_ptr<ListValue> results(ReturnsEnum::Result::Create(state));
+    ListValue expected;
+    expected.Append(Value::CreateStringValue("foo"));
+    EXPECT_TRUE(results->Equals(&expected));
+  }
+}
+
+TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) {
+  {
+    scoped_ptr<ListValue> results(ReturnsTwoEnums::Result::Create(
+        ReturnsTwoEnums::Result::FIRST_STATE_FOO,
+        ReturnsTwoEnums::Result::SECOND_STATE_HAM));
+    ListValue expected;
+    expected.Append(Value::CreateStringValue("foo"));
+    expected.Append(Value::CreateStringValue("ham"));
+    EXPECT_TRUE(results->Equals(&expected));
+  }
+}
+
 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) {
   {
     scoped_ptr<OptionalEnumType> enum_type(new OptionalEnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("two"));
+    scoped_ptr<DictionaryValue> value(
+        DictionaryBuilder().Set("type", "two").Build());
     EXPECT_TRUE(OptionalEnumType::Populate(*value, enum_type.get()));
     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()));
   }
   {
     scoped_ptr<OptionalEnumType> enum_type(new OptionalEnumType());
-    scoped_ptr<DictionaryValue> value(new DictionaryValue());
-    value->Set("type", Value::CreateStringValue("invalid"));
+    scoped_ptr<DictionaryValue> value(
+        DictionaryBuilder().Set("type", "invalid").Build());
     EXPECT_FALSE(OptionalEnumType::Populate(*value, enum_type.get()));
   }
 }
 
 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) {
   {
     scoped_ptr<ListValue> params_value(new ListValue());
     params_value->Append(Value::CreateStringValue("baz"));
     scoped_ptr<TakesEnum::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(ListBuilder().Append("invalid").Build());
     scoped_ptr<TakesEnum::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(ListBuilder().Append("baz").Build());
     scoped_ptr<TakesOptionalEnum::Params> params(
         TakesOptionalEnum::Params::Create(*params_value));
     EXPECT_TRUE(params.get());
     EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state);
   }
   {
     scoped_ptr<ListValue> params_value(new ListValue());
     scoped_ptr<TakesOptionalEnum::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(ListBuilder().Append("invalid").Build());
     scoped_ptr<TakesOptionalEnum::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(
+        ListBuilder().Append("foo").Append("foo").Build());
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(ListBuilder().Append("foo").Build());
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
         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());
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
         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"));
+    scoped_ptr<ListValue> params_value(
+        ListBuilder().Append("baz").Append("invalid").Build());
     scoped_ptr<TakesMultipleOptionalEnums::Params> params(
         TakesMultipleOptionalEnums::Params::Create(*params_value));
     EXPECT_FALSE(params.get());
   }
 }
+
+TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) {
+  {
+    OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
+    scoped_ptr<Value> result(OnEnumFired::CreateEnumValue(some_enum));
+    scoped_ptr<Value> expected(Value::CreateStringValue("foo"));
+    EXPECT_TRUE(result->Equals(expected.get()));
+  }
+  {
+    OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
+    scoped_ptr<ListValue> results(OnEnumFired::Create(some_enum));
+    scoped_ptr<ListValue> expected(ListBuilder().Append("foo").Build());
+    EXPECT_TRUE(results->Equals(expected.get()));
+  }
+}
+
+TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) {
+  {
+    scoped_ptr<Value> results(OnTwoEnumsFired::Create(
+        OnTwoEnumsFired::FIRST_ENUM_FOO,
+        OnTwoEnumsFired::SECOND_ENUM_HAM));
+    scoped_ptr<ListValue> expected(
+        ListBuilder().Append("foo").Append("ham").Build());
+    EXPECT_TRUE(results->Equals(expected.get()));
+  }
+}