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 14 matching lines...) Expand all Loading... |
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.Append(new base::StringValue("one")); |
34 | 34 |
35 scoped_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 { |
44 HasEnumeration enumeration; | 44 HasEnumeration enumeration; |
45 EXPECT_EQ(ENUMERATION_NONE, enumeration.enumeration); | 45 EXPECT_EQ(ENUMERATION_NONE, enumeration.enumeration); |
(...skipping 21 matching lines...) Expand all Loading... |
67 ASSERT_TRUE(ReferenceEnum::Populate(value, &enumeration)); | 67 ASSERT_TRUE(ReferenceEnum::Populate(value, &enumeration)); |
68 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); | 68 EXPECT_TRUE(value.Equals(enumeration.ToValue().get())); |
69 } | 69 } |
70 } | 70 } |
71 | 71 |
72 TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { | 72 TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) { |
73 { | 73 { |
74 base::ListValue params_value; | 74 base::ListValue params_value; |
75 params_value.Append(List(new base::StringValue("one"), | 75 params_value.Append(List(new base::StringValue("one"), |
76 new base::StringValue("two")).release()); | 76 new base::StringValue("two")).release()); |
77 scoped_ptr<TakesEnumArrayAsType::Params> params( | 77 std::unique_ptr<TakesEnumArrayAsType::Params> params( |
78 TakesEnumArrayAsType::Params::Create(params_value)); | 78 TakesEnumArrayAsType::Params::Create(params_value)); |
79 ASSERT_TRUE(params); | 79 ASSERT_TRUE(params); |
80 EXPECT_EQ(2U, params->values.size()); | 80 EXPECT_EQ(2U, params->values.size()); |
81 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); | 81 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); |
82 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); | 82 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); |
83 } | 83 } |
84 { | 84 { |
85 base::ListValue params_value; | 85 base::ListValue params_value; |
86 params_value.Append(List(new base::StringValue("invalid")).release()); | 86 params_value.Append(List(new base::StringValue("invalid")).release()); |
87 scoped_ptr<TakesEnumArrayAsType::Params> params( | 87 std::unique_ptr<TakesEnumArrayAsType::Params> params( |
88 TakesEnumArrayAsType::Params::Create(params_value)); | 88 TakesEnumArrayAsType::Params::Create(params_value)); |
89 EXPECT_FALSE(params); | 89 EXPECT_FALSE(params); |
90 } | 90 } |
91 } | 91 } |
92 | 92 |
93 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { | 93 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { |
94 { | 94 { |
95 Enumeration state = ENUMERATION_ONE; | 95 Enumeration state = ENUMERATION_ONE; |
96 scoped_ptr<base::Value> result(new base::StringValue(ToString(state))); | 96 std::unique_ptr<base::Value> result(new base::StringValue(ToString(state))); |
97 scoped_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 scoped_ptr<base::ListValue> results = ReturnsEnum::Results::Create(state); | 102 std::unique_ptr<base::ListValue> results = |
| 103 ReturnsEnum::Results::Create(state); |
103 base::ListValue expected; | 104 base::ListValue expected; |
104 expected.Append(new base::StringValue("one")); | 105 expected.Append(new base::StringValue("one")); |
105 EXPECT_TRUE(results->Equals(&expected)); | 106 EXPECT_TRUE(results->Equals(&expected)); |
106 } | 107 } |
107 } | 108 } |
108 | 109 |
109 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { | 110 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { |
110 { | 111 { |
111 scoped_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( | 112 std::unique_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( |
112 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); | 113 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); |
113 base::ListValue expected; | 114 base::ListValue expected; |
114 expected.Append(new base::StringValue("one")); | 115 expected.Append(new base::StringValue("one")); |
115 expected.Append(new base::StringValue("ham")); | 116 expected.Append(new base::StringValue("ham")); |
116 EXPECT_TRUE(results->Equals(&expected)); | 117 EXPECT_TRUE(results->Equals(&expected)); |
117 } | 118 } |
118 } | 119 } |
119 | 120 |
120 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { | 121 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { |
121 { | 122 { |
(...skipping 16 matching lines...) Expand all Loading... |
138 base::DictionaryValue value; | 139 base::DictionaryValue value; |
139 value.Set("type", new base::StringValue("invalid")); | 140 value.Set("type", new base::StringValue("invalid")); |
140 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); | 141 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); |
141 } | 142 } |
142 } | 143 } |
143 | 144 |
144 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { | 145 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { |
145 { | 146 { |
146 base::ListValue params_value; | 147 base::ListValue params_value; |
147 params_value.Append(new base::StringValue("two")); | 148 params_value.Append(new base::StringValue("two")); |
148 scoped_ptr<TakesEnum::Params> params( | 149 std::unique_ptr<TakesEnum::Params> params( |
149 TakesEnum::Params::Create(params_value)); | 150 TakesEnum::Params::Create(params_value)); |
150 EXPECT_TRUE(params.get()); | 151 EXPECT_TRUE(params.get()); |
151 EXPECT_EQ(ENUMERATION_TWO, params->state); | 152 EXPECT_EQ(ENUMERATION_TWO, params->state); |
152 } | 153 } |
153 { | 154 { |
154 base::ListValue params_value; | 155 base::ListValue params_value; |
155 params_value.Append(new base::StringValue("invalid")); | 156 params_value.Append(new base::StringValue("invalid")); |
156 scoped_ptr<TakesEnum::Params> params( | 157 std::unique_ptr<TakesEnum::Params> params( |
157 TakesEnum::Params::Create(params_value)); | 158 TakesEnum::Params::Create(params_value)); |
158 EXPECT_FALSE(params.get()); | 159 EXPECT_FALSE(params.get()); |
159 } | 160 } |
160 } | 161 } |
161 | 162 |
162 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { | 163 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { |
163 { | 164 { |
164 base::ListValue params_value; | 165 base::ListValue params_value; |
165 params_value.Append(List(new base::StringValue("one"), | 166 params_value.Append(List(new base::StringValue("one"), |
166 new base::StringValue("two")).release()); | 167 new base::StringValue("two")).release()); |
167 scoped_ptr<TakesEnumArray::Params> params( | 168 std::unique_ptr<TakesEnumArray::Params> params( |
168 TakesEnumArray::Params::Create(params_value)); | 169 TakesEnumArray::Params::Create(params_value)); |
169 ASSERT_TRUE(params); | 170 ASSERT_TRUE(params); |
170 EXPECT_EQ(2U, params->values.size()); | 171 EXPECT_EQ(2U, params->values.size()); |
171 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); | 172 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); |
172 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); | 173 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); |
173 } | 174 } |
174 { | 175 { |
175 base::ListValue params_value; | 176 base::ListValue params_value; |
176 params_value.Append(List(new base::StringValue("invalid")).release()); | 177 params_value.Append(List(new base::StringValue("invalid")).release()); |
177 scoped_ptr<TakesEnumArray::Params> params( | 178 std::unique_ptr<TakesEnumArray::Params> params( |
178 TakesEnumArray::Params::Create(params_value)); | 179 TakesEnumArray::Params::Create(params_value)); |
179 EXPECT_FALSE(params); | 180 EXPECT_FALSE(params); |
180 } | 181 } |
181 } | 182 } |
182 | 183 |
183 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { | 184 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { |
184 { | 185 { |
185 base::ListValue params_value; | 186 base::ListValue params_value; |
186 params_value.Append(new base::StringValue("three")); | 187 params_value.Append(new base::StringValue("three")); |
187 scoped_ptr<TakesOptionalEnum::Params> params( | 188 std::unique_ptr<TakesOptionalEnum::Params> params( |
188 TakesOptionalEnum::Params::Create(params_value)); | 189 TakesOptionalEnum::Params::Create(params_value)); |
189 EXPECT_TRUE(params.get()); | 190 EXPECT_TRUE(params.get()); |
190 EXPECT_EQ(ENUMERATION_THREE, params->state); | 191 EXPECT_EQ(ENUMERATION_THREE, params->state); |
191 } | 192 } |
192 { | 193 { |
193 base::ListValue params_value; | 194 base::ListValue params_value; |
194 scoped_ptr<TakesOptionalEnum::Params> params( | 195 std::unique_ptr<TakesOptionalEnum::Params> params( |
195 TakesOptionalEnum::Params::Create(params_value)); | 196 TakesOptionalEnum::Params::Create(params_value)); |
196 EXPECT_TRUE(params.get()); | 197 EXPECT_TRUE(params.get()); |
197 EXPECT_EQ(ENUMERATION_NONE, params->state); | 198 EXPECT_EQ(ENUMERATION_NONE, params->state); |
198 } | 199 } |
199 { | 200 { |
200 base::ListValue params_value; | 201 base::ListValue params_value; |
201 params_value.Append(new base::StringValue("invalid")); | 202 params_value.Append(new base::StringValue("invalid")); |
202 scoped_ptr<TakesOptionalEnum::Params> params( | 203 std::unique_ptr<TakesOptionalEnum::Params> params( |
203 TakesOptionalEnum::Params::Create(params_value)); | 204 TakesOptionalEnum::Params::Create(params_value)); |
204 EXPECT_FALSE(params.get()); | 205 EXPECT_FALSE(params.get()); |
205 } | 206 } |
206 } | 207 } |
207 | 208 |
208 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { | 209 TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) { |
209 { | 210 { |
210 base::ListValue params_value; | 211 base::ListValue params_value; |
211 params_value.Append(new base::StringValue("one")); | 212 params_value.Append(new base::StringValue("one")); |
212 params_value.Append(new base::StringValue("ham")); | 213 params_value.Append(new base::StringValue("ham")); |
213 scoped_ptr<TakesMultipleOptionalEnums::Params> params( | 214 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
214 TakesMultipleOptionalEnums::Params::Create(params_value)); | 215 TakesMultipleOptionalEnums::Params::Create(params_value)); |
215 EXPECT_TRUE(params.get()); | 216 EXPECT_TRUE(params.get()); |
216 EXPECT_EQ(ENUMERATION_ONE, params->state); | 217 EXPECT_EQ(ENUMERATION_ONE, params->state); |
217 EXPECT_EQ(OTHER_ENUMERATION_HAM, params->type); | 218 EXPECT_EQ(OTHER_ENUMERATION_HAM, params->type); |
218 } | 219 } |
219 { | 220 { |
220 base::ListValue params_value; | 221 base::ListValue params_value; |
221 params_value.Append(new base::StringValue("one")); | 222 params_value.Append(new base::StringValue("one")); |
222 scoped_ptr<TakesMultipleOptionalEnums::Params> params( | 223 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
223 TakesMultipleOptionalEnums::Params::Create(params_value)); | 224 TakesMultipleOptionalEnums::Params::Create(params_value)); |
224 EXPECT_TRUE(params.get()); | 225 EXPECT_TRUE(params.get()); |
225 EXPECT_EQ(ENUMERATION_ONE, params->state); | 226 EXPECT_EQ(ENUMERATION_ONE, params->state); |
226 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); | 227 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); |
227 } | 228 } |
228 { | 229 { |
229 base::ListValue params_value; | 230 base::ListValue params_value; |
230 scoped_ptr<TakesMultipleOptionalEnums::Params> params( | 231 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
231 TakesMultipleOptionalEnums::Params::Create(params_value)); | 232 TakesMultipleOptionalEnums::Params::Create(params_value)); |
232 EXPECT_TRUE(params.get()); | 233 EXPECT_TRUE(params.get()); |
233 EXPECT_EQ(ENUMERATION_NONE, params->state); | 234 EXPECT_EQ(ENUMERATION_NONE, params->state); |
234 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); | 235 EXPECT_EQ(OTHER_ENUMERATION_NONE, params->type); |
235 } | 236 } |
236 { | 237 { |
237 base::ListValue params_value; | 238 base::ListValue params_value; |
238 params_value.Append(new base::StringValue("three")); | 239 params_value.Append(new base::StringValue("three")); |
239 params_value.Append(new base::StringValue("invalid")); | 240 params_value.Append(new base::StringValue("invalid")); |
240 scoped_ptr<TakesMultipleOptionalEnums::Params> params( | 241 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
241 TakesMultipleOptionalEnums::Params::Create(params_value)); | 242 TakesMultipleOptionalEnums::Params::Create(params_value)); |
242 EXPECT_FALSE(params.get()); | 243 EXPECT_FALSE(params.get()); |
243 } | 244 } |
244 } | 245 } |
245 | 246 |
246 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { | 247 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { |
247 { | 248 { |
248 Enumeration some_enum = ENUMERATION_ONE; | 249 Enumeration some_enum = ENUMERATION_ONE; |
249 scoped_ptr<base::Value> result(new base::StringValue(ToString(some_enum))); | 250 std::unique_ptr<base::Value> result( |
250 scoped_ptr<base::Value> expected(new base::StringValue("one")); | 251 new base::StringValue(ToString(some_enum))); |
| 252 std::unique_ptr<base::Value> expected(new base::StringValue("one")); |
251 EXPECT_TRUE(result->Equals(expected.get())); | 253 EXPECT_TRUE(result->Equals(expected.get())); |
252 } | 254 } |
253 { | 255 { |
254 Enumeration some_enum = ENUMERATION_ONE; | 256 Enumeration some_enum = ENUMERATION_ONE; |
255 scoped_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); | 257 std::unique_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); |
256 base::ListValue expected; | 258 base::ListValue expected; |
257 expected.Append(new base::StringValue("one")); | 259 expected.Append(new base::StringValue("one")); |
258 EXPECT_TRUE(results->Equals(&expected)); | 260 EXPECT_TRUE(results->Equals(&expected)); |
259 } | 261 } |
260 } | 262 } |
261 | 263 |
262 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { | 264 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { |
263 { | 265 { |
264 scoped_ptr<base::Value> results( | 266 std::unique_ptr<base::Value> results( |
265 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); | 267 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); |
266 base::ListValue expected; | 268 base::ListValue expected; |
267 expected.Append(new base::StringValue("one")); | 269 expected.Append(new base::StringValue("one")); |
268 expected.Append(new base::StringValue("ham")); | 270 expected.Append(new base::StringValue("ham")); |
269 EXPECT_TRUE(results->Equals(&expected)); | 271 EXPECT_TRUE(results->Equals(&expected)); |
270 } | 272 } |
271 } | 273 } |
OLD | NEW |