OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "tools/json_schema_compiler/test/enums.h" | 5 #include "tools/json_schema_compiler/test/enums.h" |
6 | 6 |
7 #include "testing/gtest/include/gtest/gtest.h" | 7 #include "testing/gtest/include/gtest/gtest.h" |
8 #include "tools/json_schema_compiler/test/test_util.h" | 8 #include "tools/json_schema_compiler/test/test_util.h" |
9 | 9 |
10 using namespace test::api::enums; | 10 using namespace test::api::enums; |
(...skipping 12 matching lines...) Expand all Loading... |
23 EnumType enum_type; | 23 EnumType enum_type; |
24 base::DictionaryValue value; | 24 base::DictionaryValue value; |
25 value.Set("type", new base::StringValue("invalid")); | 25 value.Set("type", new base::StringValue("invalid")); |
26 EXPECT_FALSE(EnumType::Populate(value, &enum_type)); | 26 EXPECT_FALSE(EnumType::Populate(value, &enum_type)); |
27 } | 27 } |
28 } | 28 } |
29 | 29 |
30 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { | 30 TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) { |
31 { | 31 { |
32 base::ListValue args; | 32 base::ListValue args; |
33 args.Append(new base::StringValue("one")); | 33 args.AppendString("one"); |
34 | 34 |
35 std::unique_ptr<TakesEnumAsType::Params> params( | 35 std::unique_ptr<TakesEnumAsType::Params> params( |
36 TakesEnumAsType::Params::Create(args)); | 36 TakesEnumAsType::Params::Create(args)); |
37 ASSERT_TRUE(params.get()); | 37 ASSERT_TRUE(params.get()); |
38 EXPECT_EQ(ENUMERATION_ONE, params->enumeration); | 38 EXPECT_EQ(ENUMERATION_ONE, params->enumeration); |
39 | 39 |
40 EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create( | 40 EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create( |
41 ENUMERATION_ONE).get())); | 41 ENUMERATION_ONE).get())); |
42 } | 42 } |
43 { | 43 { |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
95 Enumeration state = ENUMERATION_ONE; | 95 Enumeration state = ENUMERATION_ONE; |
96 std::unique_ptr<base::Value> result(new base::StringValue(ToString(state))); | 96 std::unique_ptr<base::Value> result(new base::StringValue(ToString(state))); |
97 std::unique_ptr<base::Value> expected(new base::StringValue("one")); | 97 std::unique_ptr<base::Value> expected(new base::StringValue("one")); |
98 EXPECT_TRUE(result->Equals(expected.get())); | 98 EXPECT_TRUE(result->Equals(expected.get())); |
99 } | 99 } |
100 { | 100 { |
101 Enumeration state = ENUMERATION_ONE; | 101 Enumeration state = ENUMERATION_ONE; |
102 std::unique_ptr<base::ListValue> results = | 102 std::unique_ptr<base::ListValue> results = |
103 ReturnsEnum::Results::Create(state); | 103 ReturnsEnum::Results::Create(state); |
104 base::ListValue expected; | 104 base::ListValue expected; |
105 expected.Append(new base::StringValue("one")); | 105 expected.AppendString("one"); |
106 EXPECT_TRUE(results->Equals(&expected)); | 106 EXPECT_TRUE(results->Equals(&expected)); |
107 } | 107 } |
108 } | 108 } |
109 | 109 |
110 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { | 110 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { |
111 { | 111 { |
112 std::unique_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( | 112 std::unique_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( |
113 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); | 113 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); |
114 base::ListValue expected; | 114 base::ListValue expected; |
115 expected.Append(new base::StringValue("one")); | 115 expected.AppendString("one"); |
116 expected.Append(new base::StringValue("ham")); | 116 expected.AppendString("ham"); |
117 EXPECT_TRUE(results->Equals(&expected)); | 117 EXPECT_TRUE(results->Equals(&expected)); |
118 } | 118 } |
119 } | 119 } |
120 | 120 |
121 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { | 121 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { |
122 { | 122 { |
123 OptionalEnumType enum_type; | 123 OptionalEnumType enum_type; |
124 base::DictionaryValue value; | 124 base::DictionaryValue value; |
125 value.Set("type", new base::StringValue("two")); | 125 value.Set("type", new base::StringValue("two")); |
126 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); | 126 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); |
(...skipping 11 matching lines...) Expand all Loading... |
138 OptionalEnumType enum_type; | 138 OptionalEnumType enum_type; |
139 base::DictionaryValue value; | 139 base::DictionaryValue value; |
140 value.Set("type", new base::StringValue("invalid")); | 140 value.Set("type", new base::StringValue("invalid")); |
141 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); | 141 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); |
142 } | 142 } |
143 } | 143 } |
144 | 144 |
145 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { | 145 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { |
146 { | 146 { |
147 base::ListValue params_value; | 147 base::ListValue params_value; |
148 params_value.Append(new base::StringValue("two")); | 148 params_value.AppendString("two"); |
149 std::unique_ptr<TakesEnum::Params> params( | 149 std::unique_ptr<TakesEnum::Params> params( |
150 TakesEnum::Params::Create(params_value)); | 150 TakesEnum::Params::Create(params_value)); |
151 EXPECT_TRUE(params.get()); | 151 EXPECT_TRUE(params.get()); |
152 EXPECT_EQ(ENUMERATION_TWO, params->state); | 152 EXPECT_EQ(ENUMERATION_TWO, params->state); |
153 } | 153 } |
154 { | 154 { |
155 base::ListValue params_value; | 155 base::ListValue params_value; |
156 params_value.Append(new base::StringValue("invalid")); | 156 params_value.AppendString("invalid"); |
157 std::unique_ptr<TakesEnum::Params> params( | 157 std::unique_ptr<TakesEnum::Params> params( |
158 TakesEnum::Params::Create(params_value)); | 158 TakesEnum::Params::Create(params_value)); |
159 EXPECT_FALSE(params.get()); | 159 EXPECT_FALSE(params.get()); |
160 } | 160 } |
161 } | 161 } |
162 | 162 |
163 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { | 163 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { |
164 { | 164 { |
165 base::ListValue params_value; | 165 base::ListValue params_value; |
166 params_value.Append(List(new base::StringValue("one"), | 166 params_value.Append(List(new base::StringValue("one"), |
(...skipping 10 matching lines...) Expand all Loading... |
177 params_value.Append(List(new base::StringValue("invalid")).release()); | 177 params_value.Append(List(new base::StringValue("invalid")).release()); |
178 std::unique_ptr<TakesEnumArray::Params> params( | 178 std::unique_ptr<TakesEnumArray::Params> params( |
179 TakesEnumArray::Params::Create(params_value)); | 179 TakesEnumArray::Params::Create(params_value)); |
180 EXPECT_FALSE(params); | 180 EXPECT_FALSE(params); |
181 } | 181 } |
182 } | 182 } |
183 | 183 |
184 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { | 184 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { |
185 { | 185 { |
186 base::ListValue params_value; | 186 base::ListValue params_value; |
187 params_value.Append(new base::StringValue("three")); | 187 params_value.AppendString("three"); |
188 std::unique_ptr<TakesOptionalEnum::Params> params( | 188 std::unique_ptr<TakesOptionalEnum::Params> params( |
189 TakesOptionalEnum::Params::Create(params_value)); | 189 TakesOptionalEnum::Params::Create(params_value)); |
190 EXPECT_TRUE(params.get()); | 190 EXPECT_TRUE(params.get()); |
191 EXPECT_EQ(ENUMERATION_THREE, params->state); | 191 EXPECT_EQ(ENUMERATION_THREE, params->state); |
192 } | 192 } |
193 { | 193 { |
194 base::ListValue params_value; | 194 base::ListValue params_value; |
195 std::unique_ptr<TakesOptionalEnum::Params> params( | 195 std::unique_ptr<TakesOptionalEnum::Params> params( |
196 TakesOptionalEnum::Params::Create(params_value)); | 196 TakesOptionalEnum::Params::Create(params_value)); |
197 EXPECT_TRUE(params.get()); | 197 EXPECT_TRUE(params.get()); |
198 EXPECT_EQ(ENUMERATION_NONE, params->state); | 198 EXPECT_EQ(ENUMERATION_NONE, params->state); |
199 } | 199 } |
200 { | 200 { |
201 base::ListValue params_value; | 201 base::ListValue params_value; |
202 params_value.Append(new base::StringValue("invalid")); | 202 params_value.AppendString("invalid"); |
203 std::unique_ptr<TakesOptionalEnum::Params> params( | 203 std::unique_ptr<TakesOptionalEnum::Params> params( |
204 TakesOptionalEnum::Params::Create(params_value)); | 204 TakesOptionalEnum::Params::Create(params_value)); |
205 EXPECT_FALSE(params.get()); | 205 EXPECT_FALSE(params.get()); |
206 } | 206 } |
207 } | 207 } |
208 | 208 |
209 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { | 209 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { |
210 { | 210 { |
211 base::ListValue params_value; | 211 base::ListValue params_value; |
212 params_value.Append(new base::StringValue("one")); | 212 params_value.AppendString("one"); |
213 params_value.Append(new base::StringValue("ham")); | 213 params_value.AppendString("ham"); |
214 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( | 214 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
215 TakesMultipleOptionalEnums::Params::Create(params_value)); | 215 TakesMultipleOptionalEnums::Params::Create(params_value)); |
216 EXPECT_TRUE(params.get()); | 216 EXPECT_TRUE(params.get()); |
217 EXPECT_EQ(ENUMERATION_ONE, params->state); | 217 EXPECT_EQ(ENUMERATION_ONE, params->state); |
218 EXPECT_EQ(OTHER_ENUMERATION_HAM, params->type); | 218 EXPECT_EQ(OTHER_ENUMERATION_HAM, params->type); |
219 } | 219 } |
220 { | 220 { |
221 base::ListValue params_value; | 221 base::ListValue params_value; |
222 params_value.Append(new base::StringValue("one")); | 222 params_value.AppendString("one"); |
223 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( | 223 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
224 TakesMultipleOptionalEnums::Params::Create(params_value)); | 224 TakesMultipleOptionalEnums::Params::Create(params_value)); |
225 EXPECT_TRUE(params.get()); | 225 EXPECT_TRUE(params.get()); |
226 EXPECT_EQ(ENUMERATION_ONE, params->state); | 226 EXPECT_EQ(ENUMERATION_ONE, params->state); |
227 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); | 227 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); |
228 } | 228 } |
229 { | 229 { |
230 base::ListValue params_value; | 230 base::ListValue params_value; |
231 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( | 231 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
232 TakesMultipleOptionalEnums::Params::Create(params_value)); | 232 TakesMultipleOptionalEnums::Params::Create(params_value)); |
233 EXPECT_TRUE(params.get()); | 233 EXPECT_TRUE(params.get()); |
234 EXPECT_EQ(ENUMERATION_NONE, params->state); | 234 EXPECT_EQ(ENUMERATION_NONE, params->state); |
235 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); | 235 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); |
236 } | 236 } |
237 { | 237 { |
238 base::ListValue params_value; | 238 base::ListValue params_value; |
239 params_value.Append(new base::StringValue("three")); | 239 params_value.AppendString("three"); |
240 params_value.Append(new base::StringValue("invalid")); | 240 params_value.AppendString("invalid"); |
241 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( | 241 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
242 TakesMultipleOptionalEnums::Params::Create(params_value)); | 242 TakesMultipleOptionalEnums::Params::Create(params_value)); |
243 EXPECT_FALSE(params.get()); | 243 EXPECT_FALSE(params.get()); |
244 } | 244 } |
245 } | 245 } |
246 | 246 |
247 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { | 247 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { |
248 { | 248 { |
249 Enumeration some_enum = ENUMERATION_ONE; | 249 Enumeration some_enum = ENUMERATION_ONE; |
250 std::unique_ptr<base::Value> result( | 250 std::unique_ptr<base::Value> result( |
251 new base::StringValue(ToString(some_enum))); | 251 new base::StringValue(ToString(some_enum))); |
252 std::unique_ptr<base::Value> expected(new base::StringValue("one")); | 252 std::unique_ptr<base::Value> expected(new base::StringValue("one")); |
253 EXPECT_TRUE(result->Equals(expected.get())); | 253 EXPECT_TRUE(result->Equals(expected.get())); |
254 } | 254 } |
255 { | 255 { |
256 Enumeration some_enum = ENUMERATION_ONE; | 256 Enumeration some_enum = ENUMERATION_ONE; |
257 std::unique_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); | 257 std::unique_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); |
258 base::ListValue expected; | 258 base::ListValue expected; |
259 expected.Append(new base::StringValue("one")); | 259 expected.AppendString("one"); |
260 EXPECT_TRUE(results->Equals(&expected)); | 260 EXPECT_TRUE(results->Equals(&expected)); |
261 } | 261 } |
262 } | 262 } |
263 | 263 |
264 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { | 264 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { |
265 { | 265 { |
266 std::unique_ptr<base::Value> results( | 266 std::unique_ptr<base::Value> results( |
267 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); | 267 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); |
268 base::ListValue expected; | 268 base::ListValue expected; |
269 expected.Append(new base::StringValue("one")); | 269 expected.AppendString("one"); |
270 expected.Append(new base::StringValue("ham")); | 270 expected.AppendString("ham"); |
271 EXPECT_TRUE(results->Equals(&expected)); | 271 EXPECT_TRUE(results->Equals(&expected)); |
272 } | 272 } |
273 } | 273 } |
OLD | NEW |