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