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", new base::StringValue("one")); | 17 value.Set("type", new base::Value("one")); |
18 EXPECT_TRUE(EnumType::Populate(value, &enum_type)); | 18 EXPECT_TRUE(EnumType::Populate(value, &enum_type)); |
19 EXPECT_EQ(ENUMERATION_ONE, enum_type.type); | 19 EXPECT_EQ(ENUMERATION_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", new base::StringValue("invalid")); | 25 value.Set("type", new base::Value("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.AppendString("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 { |
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", new base::StringValue("one")); | 53 value.Set("enumeration", new base::Value("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", new base::StringValue("two")); | 57 value.Set("optional_enumeration", new base::Value("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 ReferenceEnum enumeration; | 62 ReferenceEnum enumeration; |
63 base::DictionaryValue value; | 63 base::DictionaryValue value; |
64 ASSERT_FALSE(ReferenceEnum::Populate(value, &enumeration)); | 64 ASSERT_FALSE(ReferenceEnum::Populate(value, &enumeration)); |
65 | 65 |
66 value.Set("reference_enum", new base::StringValue("one")); | 66 value.Set("reference_enum", new base::Value("one")); |
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( | 75 params_value.Append(List(new base::Value("one"), new base::Value("two"))); |
76 List(new base::StringValue("one"), new base::StringValue("two"))); | |
77 std::unique_ptr<TakesEnumArrayAsType::Params> params( | 76 std::unique_ptr<TakesEnumArrayAsType::Params> params( |
78 TakesEnumArrayAsType::Params::Create(params_value)); | 77 TakesEnumArrayAsType::Params::Create(params_value)); |
79 ASSERT_TRUE(params); | 78 ASSERT_TRUE(params); |
80 EXPECT_EQ(2U, params->values.size()); | 79 EXPECT_EQ(2U, params->values.size()); |
81 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); | 80 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); |
82 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); | 81 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); |
83 } | 82 } |
84 { | 83 { |
85 base::ListValue params_value; | 84 base::ListValue params_value; |
86 params_value.Append(List(new base::StringValue("invalid"))); | 85 params_value.Append(List(new base::Value("invalid"))); |
87 std::unique_ptr<TakesEnumArrayAsType::Params> params( | 86 std::unique_ptr<TakesEnumArrayAsType::Params> params( |
88 TakesEnumArrayAsType::Params::Create(params_value)); | 87 TakesEnumArrayAsType::Params::Create(params_value)); |
89 EXPECT_FALSE(params); | 88 EXPECT_FALSE(params); |
90 } | 89 } |
91 } | 90 } |
92 | 91 |
93 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { | 92 TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) { |
94 { | 93 { |
95 Enumeration state = ENUMERATION_ONE; | 94 Enumeration state = ENUMERATION_ONE; |
96 std::unique_ptr<base::Value> result(new base::StringValue(ToString(state))); | 95 std::unique_ptr<base::Value> result(new base::Value(ToString(state))); |
97 std::unique_ptr<base::Value> expected(new base::StringValue("one")); | 96 std::unique_ptr<base::Value> expected(new base::Value("one")); |
98 EXPECT_TRUE(result->Equals(expected.get())); | 97 EXPECT_TRUE(result->Equals(expected.get())); |
99 } | 98 } |
100 { | 99 { |
101 Enumeration state = ENUMERATION_ONE; | 100 Enumeration state = ENUMERATION_ONE; |
102 std::unique_ptr<base::ListValue> results = | 101 std::unique_ptr<base::ListValue> results = |
103 ReturnsEnum::Results::Create(state); | 102 ReturnsEnum::Results::Create(state); |
104 base::ListValue expected; | 103 base::ListValue expected; |
105 expected.AppendString("one"); | 104 expected.AppendString("one"); |
106 EXPECT_TRUE(results->Equals(&expected)); | 105 EXPECT_TRUE(results->Equals(&expected)); |
107 } | 106 } |
108 } | 107 } |
109 | 108 |
110 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { | 109 TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) { |
111 { | 110 { |
112 std::unique_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( | 111 std::unique_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create( |
113 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); | 112 ENUMERATION_ONE, OTHER_ENUMERATION_HAM); |
114 base::ListValue expected; | 113 base::ListValue expected; |
115 expected.AppendString("one"); | 114 expected.AppendString("one"); |
116 expected.AppendString("ham"); | 115 expected.AppendString("ham"); |
117 EXPECT_TRUE(results->Equals(&expected)); | 116 EXPECT_TRUE(results->Equals(&expected)); |
118 } | 117 } |
119 } | 118 } |
120 | 119 |
121 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { | 120 TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) { |
122 { | 121 { |
123 OptionalEnumType enum_type; | 122 OptionalEnumType enum_type; |
124 base::DictionaryValue value; | 123 base::DictionaryValue value; |
125 value.Set("type", new base::StringValue("two")); | 124 value.Set("type", new base::Value("two")); |
126 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); | 125 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); |
127 EXPECT_EQ(ENUMERATION_TWO, enum_type.type); | 126 EXPECT_EQ(ENUMERATION_TWO, enum_type.type); |
128 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); | 127 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); |
129 } | 128 } |
130 { | 129 { |
131 OptionalEnumType enum_type; | 130 OptionalEnumType enum_type; |
132 base::DictionaryValue value; | 131 base::DictionaryValue value; |
133 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); | 132 EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type)); |
134 EXPECT_EQ(ENUMERATION_NONE, enum_type.type); | 133 EXPECT_EQ(ENUMERATION_NONE, enum_type.type); |
135 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); | 134 EXPECT_TRUE(value.Equals(enum_type.ToValue().get())); |
136 } | 135 } |
137 { | 136 { |
138 OptionalEnumType enum_type; | 137 OptionalEnumType enum_type; |
139 base::DictionaryValue value; | 138 base::DictionaryValue value; |
140 value.Set("type", new base::StringValue("invalid")); | 139 value.Set("type", new base::Value("invalid")); |
141 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); | 140 EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type)); |
142 } | 141 } |
143 } | 142 } |
144 | 143 |
145 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { | 144 TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) { |
146 { | 145 { |
147 base::ListValue params_value; | 146 base::ListValue params_value; |
148 params_value.AppendString("two"); | 147 params_value.AppendString("two"); |
149 std::unique_ptr<TakesEnum::Params> params( | 148 std::unique_ptr<TakesEnum::Params> params( |
150 TakesEnum::Params::Create(params_value)); | 149 TakesEnum::Params::Create(params_value)); |
151 EXPECT_TRUE(params.get()); | 150 EXPECT_TRUE(params.get()); |
152 EXPECT_EQ(ENUMERATION_TWO, params->state); | 151 EXPECT_EQ(ENUMERATION_TWO, params->state); |
153 } | 152 } |
154 { | 153 { |
155 base::ListValue params_value; | 154 base::ListValue params_value; |
156 params_value.AppendString("invalid"); | 155 params_value.AppendString("invalid"); |
157 std::unique_ptr<TakesEnum::Params> params( | 156 std::unique_ptr<TakesEnum::Params> params( |
158 TakesEnum::Params::Create(params_value)); | 157 TakesEnum::Params::Create(params_value)); |
159 EXPECT_FALSE(params.get()); | 158 EXPECT_FALSE(params.get()); |
160 } | 159 } |
161 } | 160 } |
162 | 161 |
163 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { | 162 TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) { |
164 { | 163 { |
165 base::ListValue params_value; | 164 base::ListValue params_value; |
166 params_value.Append( | 165 params_value.Append(List(new base::Value("one"), new base::Value("two"))); |
167 List(new base::StringValue("one"), new base::StringValue("two"))); | |
168 std::unique_ptr<TakesEnumArray::Params> params( | 166 std::unique_ptr<TakesEnumArray::Params> params( |
169 TakesEnumArray::Params::Create(params_value)); | 167 TakesEnumArray::Params::Create(params_value)); |
170 ASSERT_TRUE(params); | 168 ASSERT_TRUE(params); |
171 EXPECT_EQ(2U, params->values.size()); | 169 EXPECT_EQ(2U, params->values.size()); |
172 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); | 170 EXPECT_EQ(ENUMERATION_ONE, params->values[0]); |
173 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); | 171 EXPECT_EQ(ENUMERATION_TWO, params->values[1]); |
174 } | 172 } |
175 { | 173 { |
176 base::ListValue params_value; | 174 base::ListValue params_value; |
177 params_value.Append(List(new base::StringValue("invalid"))); | 175 params_value.Append(List(new base::Value("invalid"))); |
178 std::unique_ptr<TakesEnumArray::Params> params( | 176 std::unique_ptr<TakesEnumArray::Params> params( |
179 TakesEnumArray::Params::Create(params_value)); | 177 TakesEnumArray::Params::Create(params_value)); |
180 EXPECT_FALSE(params); | 178 EXPECT_FALSE(params); |
181 } | 179 } |
182 } | 180 } |
183 | 181 |
184 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { | 182 TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) { |
185 { | 183 { |
186 base::ListValue params_value; | 184 base::ListValue params_value; |
187 params_value.AppendString("three"); | 185 params_value.AppendString("three"); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
240 params_value.AppendString("invalid"); | 238 params_value.AppendString("invalid"); |
241 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( | 239 std::unique_ptr<TakesMultipleOptionalEnums::Params> params( |
242 TakesMultipleOptionalEnums::Params::Create(params_value)); | 240 TakesMultipleOptionalEnums::Params::Create(params_value)); |
243 EXPECT_FALSE(params.get()); | 241 EXPECT_FALSE(params.get()); |
244 } | 242 } |
245 } | 243 } |
246 | 244 |
247 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { | 245 TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) { |
248 { | 246 { |
249 Enumeration some_enum = ENUMERATION_ONE; | 247 Enumeration some_enum = ENUMERATION_ONE; |
250 std::unique_ptr<base::Value> result( | 248 std::unique_ptr<base::Value> result(new base::Value(ToString(some_enum))); |
251 new base::StringValue(ToString(some_enum))); | 249 std::unique_ptr<base::Value> expected(new base::Value("one")); |
252 std::unique_ptr<base::Value> expected(new base::StringValue("one")); | |
253 EXPECT_TRUE(result->Equals(expected.get())); | 250 EXPECT_TRUE(result->Equals(expected.get())); |
254 } | 251 } |
255 { | 252 { |
256 Enumeration some_enum = ENUMERATION_ONE; | 253 Enumeration some_enum = ENUMERATION_ONE; |
257 std::unique_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); | 254 std::unique_ptr<base::ListValue> results(OnEnumFired::Create(some_enum)); |
258 base::ListValue expected; | 255 base::ListValue expected; |
259 expected.AppendString("one"); | 256 expected.AppendString("one"); |
260 EXPECT_TRUE(results->Equals(&expected)); | 257 EXPECT_TRUE(results->Equals(&expected)); |
261 } | 258 } |
262 } | 259 } |
263 | 260 |
264 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { | 261 TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) { |
265 { | 262 { |
266 std::unique_ptr<base::Value> results( | 263 std::unique_ptr<base::Value> results( |
267 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); | 264 OnTwoEnumsFired::Create(ENUMERATION_ONE, OTHER_ENUMERATION_HAM)); |
268 base::ListValue expected; | 265 base::ListValue expected; |
269 expected.AppendString("one"); | 266 expected.AppendString("one"); |
270 expected.AppendString("ham"); | 267 expected.AppendString("ham"); |
271 EXPECT_TRUE(results->Equals(&expected)); | 268 EXPECT_TRUE(results->Equals(&expected)); |
272 } | 269 } |
273 } | 270 } |
OLD | NEW |