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 base::DictionaryValue value; 17 value.Set("type", base::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 base::DictionaryValue value; 25 value.Set("type", base::Value::CreateStringValue("invalid")); 26 EXPECT_FALSE(EnumType::Populate(value, &enum_type)); 27 } 28 } 29 30 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { 31 { 32 base::ListValue args; 33 args.Append(base::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 EXPECT_EQ(ENUMERATION_NONE, enumeration.enumeration); 46 EXPECT_EQ(ENUMERATION_NONE, enumeration.optional_enumeration); 47 } 48 { 49 HasEnumeration enumeration; 50 base::DictionaryValue value; 51 ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration)); 52 53 value.Set("enumeration", base::Value::CreateStringValue("one")); 54 ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); 55 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); 56 57 value.Set("optional_enumeration", base::Value::CreateStringValue("two")); 58 ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration)); 59 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); 60 } 61 { 62 InlineAndReferenceEnum enumeration; 63 base::DictionaryValue value; 64 ASSERT_FALSE(InlineAndReferenceEnum::Populate(value, &enumeration)); 65 66 value.Set("inline_enum", base::Value::CreateStringValue("test2")); 67 ASSERT_FALSE(InlineAndReferenceEnum::Populate(value, &enumeration)); 68 69 value.Set("reference_enum", base::Value::CreateStringValue("one")); 70 ASSERT_TRUE(InlineAndReferenceEnum::Populate(value, &enumeration)); 71 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); 72 } 73 } 74 75 TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { 76 { 77 base::ListValue params_value; 78 params_value.Append(List(base::Value::CreateStringValue("one"), 79 base::Value::CreateStringValue("two")).release()); 80 scoped_ptr<TakesEnumArrayAsType::Params> params( 81 TakesEnumArrayAsType::Params::Create(params_value)); 82 ASSERT_TRUE(params); 83 EXPECT_EQ(2U, params->values.size()); 84 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); 85 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); 86 } 87 { 88 base::ListValue params_value; 89 params_value.Append( 90 List(base::Value::CreateStringValue("invalid")).release()); 91 scoped_ptr<TakesEnumArrayAsType::Params> params( 92 TakesEnumArrayAsType::Params::Create(params_value)); 93 EXPECT_FALSE(params); 94 } 95 } 96 97 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { 98 { 99 ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; 100 scoped_ptr<base::Value> result( 101 new base::StringValue(ReturnsEnum::Results::ToString(state))); 102 scoped_ptr<base::Value> expected(base::Value::CreateStringValue("foo")); 103 EXPECT_TRUE(result->Equals(expected.get())); 104 } 105 { 106 ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO; 107 scoped_ptr<base::ListValue> results = ReturnsEnum::Results::Create(state); 108 base::ListValue expected; 109 expected.Append(base::Value::CreateStringValue("foo")); 110 EXPECT_TRUE(results->Equals(&expected)); 111 } 112 } 113 114 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { 115 { 116 scoped_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( 117 ReturnsTwoEnums::Results::FIRST_STATE_FOO, 118 ReturnsTwoEnums::Results::SECOND_STATE_HAM); 119 base::ListValue expected; 120 expected.Append(base::Value::CreateStringValue("foo")); 121 expected.Append(base::Value::CreateStringValue("ham")); 122 EXPECT_TRUE(results->Equals(&expected)); 123 } 124 } 125 126 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { 127 { 128 OptionalEnumType enum_type; 129 base::DictionaryValue value; 130 value.Set("type", base::Value::CreateStringValue("two")); 131 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); 132 EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type.type); 133 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); 134 } 135 { 136 OptionalEnumType enum_type; 137 base::DictionaryValue value; 138 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); 139 EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type.type); 140 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); 141 } 142 { 143 OptionalEnumType enum_type; 144 base::DictionaryValue value; 145 value.Set("type", base::Value::CreateStringValue("invalid")); 146 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); 147 } 148 } 149 150 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { 151 { 152 base::ListValue params_value; 153 params_value.Append(base::Value::CreateStringValue("baz")); 154 scoped_ptr<TakesEnum::Params> params( 155 TakesEnum::Params::Create(params_value)); 156 EXPECT_TRUE(params.get()); 157 EXPECT_EQ(TakesEnum::Params::STATE_BAZ, params->state); 158 } 159 { 160 base::ListValue params_value; 161 params_value.Append(base::Value::CreateStringValue("invalid")); 162 scoped_ptr<TakesEnum::Params> params( 163 TakesEnum::Params::Create(params_value)); 164 EXPECT_FALSE(params.get()); 165 } 166 } 167 168 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { 169 { 170 base::ListValue params_value; 171 params_value.Append(List(base::Value::CreateStringValue("foo"), 172 base::Value::CreateStringValue("bar")).release()); 173 scoped_ptr<TakesEnumArray::Params> params( 174 TakesEnumArray::Params::Create(params_value)); 175 ASSERT_TRUE(params); 176 EXPECT_EQ(2U, params->values.size()); 177 EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_FOO, params->values[0]); 178 EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_BAR, params->values[1]); 179 } 180 { 181 base::ListValue params_value; 182 params_value.Append( 183 List(base::Value::CreateStringValue("invalid")).release()); 184 scoped_ptr<TakesEnumArray::Params> params( 185 TakesEnumArray::Params::Create(params_value)); 186 EXPECT_FALSE(params); 187 } 188 } 189 190 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { 191 { 192 base::ListValue params_value; 193 params_value.Append(base::Value::CreateStringValue("baz")); 194 scoped_ptr<TakesOptionalEnum::Params> params( 195 TakesOptionalEnum::Params::Create(params_value)); 196 EXPECT_TRUE(params.get()); 197 EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state); 198 } 199 { 200 base::ListValue params_value; 201 scoped_ptr<TakesOptionalEnum::Params> params( 202 TakesOptionalEnum::Params::Create(params_value)); 203 EXPECT_TRUE(params.get()); 204 EXPECT_EQ(TakesOptionalEnum::Params::STATE_NONE, params->state); 205 } 206 { 207 base::ListValue params_value; 208 params_value.Append(base::Value::CreateStringValue("invalid")); 209 scoped_ptr<TakesOptionalEnum::Params> params( 210 TakesOptionalEnum::Params::Create(params_value)); 211 EXPECT_FALSE(params.get()); 212 } 213 } 214 215 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { 216 { 217 base::ListValue params_value; 218 params_value.Append(base::Value::CreateStringValue("foo")); 219 params_value.Append(base::Value::CreateStringValue("foo")); 220 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 221 TakesMultipleOptionalEnums::Params::Create(params_value)); 222 EXPECT_TRUE(params.get()); 223 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state); 224 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_FOO, params->type); 225 } 226 { 227 base::ListValue params_value; 228 params_value.Append(base::Value::CreateStringValue("foo")); 229 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 230 TakesMultipleOptionalEnums::Params::Create(params_value)); 231 EXPECT_TRUE(params.get()); 232 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state); 233 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); 234 } 235 { 236 base::ListValue params_value; 237 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 238 TakesMultipleOptionalEnums::Params::Create(params_value)); 239 EXPECT_TRUE(params.get()); 240 EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_NONE, params->state); 241 EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type); 242 } 243 { 244 base::ListValue params_value; 245 params_value.Append(base::Value::CreateStringValue("baz")); 246 params_value.Append(base::Value::CreateStringValue("invalid")); 247 scoped_ptr<TakesMultipleOptionalEnums::Params> params( 248 TakesMultipleOptionalEnums::Params::Create(params_value)); 249 EXPECT_FALSE(params.get()); 250 } 251 } 252 253 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { 254 { 255 OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; 256 scoped_ptr<base::Value> result( 257 new base::StringValue(OnEnumFired::ToString(some_enum))); 258 scoped_ptr<base::Value> expected(base::Value::CreateStringValue("foo")); 259 EXPECT_TRUE(result->Equals(expected.get())); 260 } 261 { 262 OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO; 263 scoped_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); 264 base::ListValue expected; 265 expected.Append(base::Value::CreateStringValue("foo")); 266 EXPECT_TRUE(results->Equals(&expected)); 267 } 268 } 269 270 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { 271 { 272 scoped_ptr<base::Value> results(OnTwoEnumsFired::Create( 273 OnTwoEnumsFired::FIRST_ENUM_FOO, 274 OnTwoEnumsFired::SECOND_ENUM_HAM)); 275 base::ListValue expected; 276 expected.Append(base::Value::CreateStringValue("foo")); 277 expected.Append(base::Value::CreateStringValue("ham")); 278 EXPECT_TRUE(results->Equals(&expected)); 279 } 280 } 281
