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