Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / tools / json_schema_compiler / test / arrays_unittest.cc

diff --git a/src/tools/json_schema_compiler/test/arrays_unittest.cc b/src/tools/json_schema_compiler/test/arrays_unittest.cc
index 9aca730..79ebfb2 100644 (file)
--- a/src/tools/json_schema_compiler/test/arrays_unittest.cc
+++ b/src/tools/json_schema_compiler/test/arrays_unittest.cc
@@ -5,6 +5,7 @@
 #include "tools/json_schema_compiler/test/arrays.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "tools/json_schema_compiler/test/enums.h"
 
 using namespace test::api::arrays;
 
@@ -14,19 +15,19 @@ namespace {
 static scoped_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() {
   base::DictionaryValue* value = new base::DictionaryValue();
   base::ListValue* strings_value = new base::ListValue();
-  strings_value->Append(base::Value::CreateStringValue("a"));
-  strings_value->Append(base::Value::CreateStringValue("b"));
-  strings_value->Append(base::Value::CreateStringValue("c"));
-  strings_value->Append(base::Value::CreateStringValue("it's easy as"));
+  strings_value->Append(new base::StringValue("a"));
+  strings_value->Append(new base::StringValue("b"));
+  strings_value->Append(new base::StringValue("c"));
+  strings_value->Append(new base::StringValue("it's easy as"));
   base::ListValue* integers_value = new base::ListValue();
-  integers_value->Append(base::Value::CreateIntegerValue(1));
-  integers_value->Append(base::Value::CreateIntegerValue(2));
-  integers_value->Append(base::Value::CreateIntegerValue(3));
+  integers_value->Append(new base::FundamentalValue(1));
+  integers_value->Append(new base::FundamentalValue(2));
+  integers_value->Append(new base::FundamentalValue(3));
   base::ListValue* booleans_value = new base::ListValue();
-  booleans_value->Append(base::Value::CreateBooleanValue(false));
-  booleans_value->Append(base::Value::CreateBooleanValue(true));
+  booleans_value->Append(new base::FundamentalValue(false));
+  booleans_value->Append(new base::FundamentalValue(true));
   base::ListValue* numbers_value = new base::ListValue();
-  numbers_value->Append(base::Value::CreateDoubleValue(6.1));
+  numbers_value->Append(new base::FundamentalValue(6.1));
   value->Set("numbers", numbers_value);
   value->Set("booleans", booleans_value);
   value->Set("strings", strings_value);
@@ -36,7 +37,7 @@ static scoped_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() {
 
 static base::Value* CreateItemValue(int val) {
   base::DictionaryValue* value(new base::DictionaryValue());
-  value->Set("val", base::Value::CreateIntegerValue(val));
+  value->Set("val", new base::FundamentalValue(val));
   return value;
 }
 
@@ -80,6 +81,87 @@ TEST(JsonSchemaCompilerArrayTest, EnumArrayType) {
   EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
 }
 
+TEST(JsonSchemaCompilerArrayTest, EnumArrayReference) {
+  // { "types": ["one", "two", "three"] }
+  base::ListValue* types = new base::ListValue();
+  types->AppendString("one");
+  types->AppendString("two");
+  types->AppendString("three");
+  base::DictionaryValue value;
+  value.Set("types", types);
+
+  EnumArrayReference enum_array_reference;
+
+  // Test Populate.
+  ASSERT_TRUE(EnumArrayReference::Populate(value, &enum_array_reference));
+
+  Enumeration expected_types[] = {ENUMERATION_ONE, ENUMERATION_TWO,
+                                  ENUMERATION_THREE};
+  EXPECT_EQ(std::vector<Enumeration>(
+                expected_types, expected_types + arraysize(expected_types)),
+            enum_array_reference.types);
+
+  // Test ToValue.
+  scoped_ptr<base::Value> as_value(enum_array_reference.ToValue());
+  EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
+}
+
+TEST(JsonSchemaCompilerArrayTest, EnumArrayMixed) {
+  // { "types": ["one", "two", "three"] }
+  base::ListValue* inline_enums = new base::ListValue();
+  inline_enums->AppendString("one");
+  inline_enums->AppendString("two");
+  inline_enums->AppendString("three");
+
+  base::ListValue* infile_enums = new base::ListValue();
+  infile_enums->AppendString("one");
+  infile_enums->AppendString("two");
+  infile_enums->AppendString("three");
+
+  base::ListValue* external_enums = new base::ListValue();
+  external_enums->AppendString("one");
+  external_enums->AppendString("two");
+  external_enums->AppendString("three");
+
+  base::DictionaryValue value;
+  value.Set("inline_enums", inline_enums);
+  value.Set("infile_enums", infile_enums);
+  value.Set("external_enums", external_enums);
+
+  EnumArrayMixed enum_array_mixed;
+
+  // Test Populate.
+  ASSERT_TRUE(EnumArrayMixed::Populate(value, &enum_array_mixed));
+
+  EnumArrayMixed::Inline_enumsType expected_inline_types[] = {
+      EnumArrayMixed::INLINE_ENUMS_TYPE_ONE,
+      EnumArrayMixed::INLINE_ENUMS_TYPE_TWO,
+      EnumArrayMixed::INLINE_ENUMS_TYPE_THREE};
+  EXPECT_EQ(std::vector<EnumArrayMixed::Inline_enumsType>(
+                expected_inline_types,
+                expected_inline_types + arraysize(expected_inline_types)),
+            enum_array_mixed.inline_enums);
+
+  Enumeration expected_infile_types[] = {ENUMERATION_ONE, ENUMERATION_TWO,
+                                         ENUMERATION_THREE};
+  EXPECT_EQ(std::vector<Enumeration>(
+                expected_infile_types,
+                expected_infile_types + arraysize(expected_infile_types)),
+            enum_array_mixed.infile_enums);
+
+  test::api::enums::Enumeration expected_external_types[] = {
+      test::api::enums::ENUMERATION_ONE, test::api::enums::ENUMERATION_TWO,
+      test::api::enums::ENUMERATION_THREE};
+  EXPECT_EQ(std::vector<test::api::enums::Enumeration>(
+                expected_external_types,
+                expected_external_types + arraysize(expected_external_types)),
+            enum_array_mixed.external_enums);
+
+  // Test ToValue.
+  scoped_ptr<base::Value> as_value(enum_array_mixed.ToValue());
+  EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
+}
+
 TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) {
   {
     std::vector<OptionalEnumArrayType::TypesType> enums;
@@ -103,7 +185,7 @@ TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) {
   {
     base::DictionaryValue value;
     scoped_ptr<base::ListValue> enum_array(new base::ListValue());
-    enum_array->Append(base::Value::CreateStringValue("invalid"));
+    enum_array->Append(new base::StringValue("invalid"));
 
     value.Set("types", enum_array.release());
     OptionalEnumArrayType enum_array_type;
@@ -131,7 +213,7 @@ TEST(JsonSchemaCompilerArrayTest, RefArrayType) {
     scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
     scoped_ptr<base::ListValue> not_ref_array(new base::ListValue());
     not_ref_array->Append(CreateItemValue(1));
-    not_ref_array->Append(base::Value::CreateIntegerValue(3));
+    not_ref_array->Append(new base::FundamentalValue(3));
     value->Set("refs", not_ref_array.release());
     scoped_ptr<RefArrayType> ref_array_type(new RefArrayType());
     EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get()));
@@ -141,9 +223,9 @@ TEST(JsonSchemaCompilerArrayTest, RefArrayType) {
 TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) {
   scoped_ptr<base::ListValue> params_value(new base::ListValue());
   scoped_ptr<base::ListValue> integer_array(new base::ListValue());
-  integer_array->Append(base::Value::CreateIntegerValue(2));
-  integer_array->Append(base::Value::CreateIntegerValue(4));
-  integer_array->Append(base::Value::CreateIntegerValue(8));
+  integer_array->Append(new base::FundamentalValue(2));
+  integer_array->Append(new base::FundamentalValue(4));
+  integer_array->Append(new base::FundamentalValue(8));
   params_value->Append(integer_array.release());
   scoped_ptr<IntegerArray::Params> params(
       IntegerArray::Params::Create(*params_value));
@@ -157,8 +239,8 @@ TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) {
 TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) {
   scoped_ptr<base::ListValue> params_value(new base::ListValue());
   scoped_ptr<base::ListValue> any_array(new base::ListValue());
-  any_array->Append(base::Value::CreateIntegerValue(1));
-  any_array->Append(base::Value::CreateStringValue("test"));
+  any_array->Append(new base::FundamentalValue(1));
+  any_array->Append(new base::StringValue("test"));
   any_array->Append(CreateItemValue(2));
   params_value->Append(any_array.release());
   scoped_ptr<AnyArray::Params> params(
@@ -207,8 +289,8 @@ TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) {
 
   base::ListValue expected;
   base::ListValue* expected_argument = new base::ListValue();
-  expected_argument->Append(base::Value::CreateIntegerValue(1));
-  expected_argument->Append(base::Value::CreateIntegerValue(2));
+  expected_argument->Append(new base::FundamentalValue(1));
+  expected_argument->Append(new base::FundamentalValue(2));
   expected.Append(expected_argument);
   EXPECT_TRUE(results->Equals(&expected));
 }