1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "tools/json_schema_compiler/test/enums.h" 6 7 #include "testing/gtest/include/gtest/gtest.h" 8 #include "tools/json_schema_compiler/test/test_util.h" 9 10 using namespace test::api::enums; 11 using json_schema_compiler::test_util::List; 12 13 TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) { 14 { 15 EnumType enum_type; 16 DictionaryValue value; 17 value.Set("type", Value::CreateStringValue("one")); 18 EXPECT_TRUE(EnumType::Populate(value, &enum_type)); 19 EXPECT_EQ(EnumType::TYPE_ONE, enum_type.type); 20 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); 21 } 22 { 23 EnumType enum_type; 24 DictionaryValue value; 25 value.Set("type", Value::CreateStringValue("invalid")); 26 EXPECT_FALSE(EnumType::Populate(value, &enum_type)); 27 } 28 } 29 30 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { 31 { 32 ListValue args; 33 args.Append(Value::CreateStringValue("one")); 34 35 scoped_ptr<TakesEnumAsType::Params> params( 36 TakesEnumAsType::Params::Create(args)); 37 ASSERT_TRUE(params.get()); 38 EXPECT_EQ(ENUMERATION_ONE, params->enumeration); 39 40 EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create( 41 ENUMERATION_ONE).get())); 42 } 43 { 44 HasEnumeration enumeration; 45 DictionaryValue value; 46 ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration)); 47 48 value.Set("enumeration", Value::CreateStringValue("one")); 49 ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); 50 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); 51 52 value.Set("optional_enumeration", Value::CreateStringValue("two")); 53 ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); 54 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); 55 } 56 } 57 58 TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { 59 { 60 ListValue params_value; 61 params_value.Append(List(Value::CreateStringValue("one"), 62 Value::CreateStringValue("two")).release()); 63 scoped_ptr<TakesEnumArrayAsType::Params> params( 64 TakesEnumArrayAsType::Params::Create(params_value)); 65 ASSERT_TRUE(params); 66 EXPECT_EQ(2U, params->values.size()); 67 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); 68 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); 69 } 70 { 71 ListValue params_value; 72 params_value.Append(List(Value::CreateStringValue("invalid")).release()); 73 scoped_ptr<TakesEnumArrayAsType::Params> params( 74 TakesEnumArrayAsType::Params::Create(params_value)); 75 EXPECT_FALSE(params); 76 } 77 } 78 79 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { 80 { 81 ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; 82 scoped_ptr<Value> result( 83 new base::StringValue(ReturnsEnum::Results::ToString(state))); 84 scoped_ptr<Value> expected(Value::CreateStringValue("foo")); 85 EXPECT_TRUE(result->Equals(expected.get())); 86 } 87 { 88 ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; 89 scoped_ptr<ListValue> results = ReturnsEnum::Results::Create(state); 90 ListValue expected; 91 expected.Append(Value::CreateStringValue("foo")); 92 EXPECT_TRUE(results->Equals(&expected)); 93 } 94 } 95 96 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { 97 { 98 scoped_ptr<ListValue> results = ReturnsTwoEnums::Results::Create( 99 ReturnsTwoEnums::Results::FIRST_STATE_FOO, 100 ReturnsTwoEnums::Results::SECOND_STATE_HAM); 101 ListValue expected; 102 expected.Append(Value::CreateStringValue("foo")); 103 expected.Append(Value::CreateStringValue("ham")); 104 EXPECT_TRUE(results->Equals(&expected)); 105 } 106 } 107 108 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { 109 { 110 OptionalEnumType enum_type; 111 DictionaryValue value; 112 value.Set("type", Value::CreateStringValue("two")); 113 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); 114 EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type.type); 115 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); 116 } 117 { 118 OptionalEnumType enum_type; 119 DictionaryValue value; 120 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); 121 EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type.type); 122 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); 123 } 124 { 125 OptionalEnumType enum_type; 126 DictionaryValue value; 127 value.Set("type", Value::CreateStringValue("invalid")); 128 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); 129 } 130 } 131 132 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { 133 { 134 ListValue params_value; 135 params_value.Append(Value::CreateStringValue("baz")); 136 scoped_ptr<TakesEnum::Params> params( 137 TakesEnum::Params::Create(params_value)); 138 EXPECT_TRUE(params.get()); 139 EXPECT_EQ(TakesEnum::Params::STATE_BAZ, params->state); 140 } 141 { 142 ListValue params_value; 143 params_value.Append(Value::CreateStringValue("invalid")); 144 scoped_ptr<TakesEnum::Params> params( 145 TakesEnum::Params::Create(params_value)); 146 EXPECT_FALSE(params.get()); 147 } 148 } 149 150 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { 151 { 152 ListValue params_value; 153 params_value.Append(List(Value::CreateStringValue("foo"), 154 Value::CreateStringValue("bar")).release()); 155 scoped_ptr<TakesEnumArray::Params> params( 156 TakesEnumArray::Params::Create(params_value)); 157 ASSERT_TRUE(params); 158 EXPECT_EQ(2U, params->values.size()); 159 EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_FOO, params->values[0]); 160 EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_BAR, params->values[1]); 161 } 162 { 163 ListValue params_value; 164 params_value.Append(List(Value::CreateStringValue("invalid")).release()); 165 scoped_ptr<TakesEnumArray::Params> params( 166 TakesEnumArray::Params::Create(params_value)); 167 EXPECT_FALSE(params); 168 } 169 } 170 171 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { 172 { 173 ListValue params_value; 174 params_value.Append(Value::CreateStringValue("baz")); 175 scoped_ptr<TakesOptionalEnum::Params> params( 176 TakesOptionalEnum::Params::Create(params_value)); 177 EXPECT_TRUE(params.get()); 178 EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state); 179 } 180 { 181 ListValue params_value; 182 scoped_ptr<TakesOptionalEnum::Params> params( 183 TakesOptionalEnum::Params::Create(params_value)); 184 EXPECT_TRUE(params.get()); 185 EXPECT_EQ(TakesOptionalEnum::Params::STATE_NONE, params->state); 186 } 187 { 188 ListValue params_value; 189 params_value.Append(Value::CreateStringValue("invalid")); 190 scoped_ptr<TakesOptionalEnum::Params> params( 191 TakesOptionalEnum::Params::Create(params_value)); 192 EXPECT_FALSE(params.get()); 193 } 194 } 195 196 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { 197 { 198 ListValue params_value; 199 params_value.Append(Value::CreateStringValue("foo")); 200 params_value.Append(Value::CreateStringValue("foo")); 201 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 202 TakesMultipleOptionalEnums::Params::Create(params_value)); 203 EXPECT_TRUE(params.get()); 204 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state); 205 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_FOO, params->type); 206 } 207 { 208 ListValue params_value; 209 params_value.Append(Value::CreateStringValue("foo")); 210 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 211 TakesMultipleOptionalEnums::Params::Create(params_value)); 212 EXPECT_TRUE(params.get()); 213 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state); 214 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); 215 } 216 { 217 ListValue params_value; 218 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 219 TakesMultipleOptionalEnums::Params::Create(params_value)); 220 EXPECT_TRUE(params.get()); 221 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_NONE, params->state); 222 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); 223 } 224 { 225 ListValue params_value; 226 params_value.Append(Value::CreateStringValue("baz")); 227 params_value.Append(Value::CreateStringValue("invalid")); 228 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 229 TakesMultipleOptionalEnums::Params::Create(params_value)); 230 EXPECT_FALSE(params.get()); 231 } 232 } 233 234 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { 235 { 236 OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; 237 scoped_ptr<Value> result( 238 new base::StringValue(OnEnumFired::ToString(some_enum))); 239 scoped_ptr<Value> expected(Value::CreateStringValue("foo")); 240 EXPECT_TRUE(result->Equals(expected.get())); 241 } 242 { 243 OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; 244 scoped_ptr<ListValue> results(OnEnumFired::Create(some_enum)); 245 ListValue expected; 246 expected.Append(Value::CreateStringValue("foo")); 247 EXPECT_TRUE(results->Equals(&expected)); 248 } 249 } 250 251 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { 252 { 253 scoped_ptr<Value> results(OnTwoEnumsFired::Create( 254 OnTwoEnumsFired::FIRST_ENUM_FOO, 255 OnTwoEnumsFired::SECOND_ENUM_HAM)); 256 ListValue expected; 257 expected.Append(Value::CreateStringValue("foo")); 258 expected.Append(Value::CreateStringValue("ham")); 259 EXPECT_TRUE(results->Equals(&expected)); 260 } 261 } 262