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 "base/json/json_value_converter.h" 6 7 #include <memory> 8 #include <string> 9 #include <vector> 10 11 #include "base/json/json_reader.h" 12 #include "base/memory/scoped_vector.h" 13 #include "base/strings/string_piece.h" 14 #include "base/values.h" 15 #include "testing/gtest/include/gtest/gtest.h" 16 17 namespace base { 18 namespace { 19 20 // Very simple messages. 21 struct SimpleMessage { 22 enum SimpleEnum { 23 FOO, BAR, 24 }; 25 int foo; 26 std::string bar; 27 bool baz; 28 bool bstruct; 29 SimpleEnum simple_enum; 30 ScopedVector<int> ints; 31 ScopedVector<std::string> string_values; 32 SimpleMessage() : foo(0), baz(false), bstruct(false), simple_enum(FOO) {} 33 34 static bool ParseSimpleEnum(const StringPiece& value, SimpleEnum* field) { 35 if (value == "foo") { 36 *field = FOO; 37 return true; 38 } else if (value == "bar") { 39 *field = BAR; 40 return true; 41 } 42 return false; 43 } 44 45 static bool HasFieldPresent(const base::Value* value, bool* result) { 46 *result = value != NULL; 47 return true; 48 } 49 50 static bool GetValueString(const base::Value* value, std::string* result) { 51 const base::DictionaryValue* dict = NULL; 52 if (!value->GetAsDictionary(&dict)) 53 return false; 54 55 if (!dict->GetString("val", result)) 56 return false; 57 58 return true; 59 } 60 61 static void RegisterJSONConverter( 62 base::JSONValueConverter<SimpleMessage>* converter) { 63 converter->RegisterIntField("foo", &SimpleMessage::foo); 64 converter->RegisterStringField("bar", &SimpleMessage::bar); 65 converter->RegisterBoolField("baz", &SimpleMessage::baz); 66 converter->RegisterCustomField<SimpleEnum>( 67 "simple_enum", &SimpleMessage::simple_enum, &ParseSimpleEnum); 68 converter->RegisterRepeatedInt("ints", &SimpleMessage::ints); 69 converter->RegisterCustomValueField<bool>("bstruct", 70 &SimpleMessage::bstruct, 71 &HasFieldPresent); 72 converter->RegisterRepeatedCustomValue<std::string>( 73 "string_values", 74 &SimpleMessage::string_values, 75 &GetValueString); 76 } 77 }; 78 79 // For nested messages. 80 struct NestedMessage { 81 double foo; 82 SimpleMessage child; 83 ScopedVector<SimpleMessage> children; 84 85 NestedMessage() : foo(0) {} 86 87 static void RegisterJSONConverter( 88 base::JSONValueConverter<NestedMessage>* converter) { 89 converter->RegisterDoubleField("foo", &NestedMessage::foo); 90 converter->RegisterNestedField("child", &NestedMessage::child); 91 converter->RegisterRepeatedMessage("children", &NestedMessage::children); 92 } 93 }; 94 95 } // namespace 96 97 TEST(JSONValueConverterTest, ParseSimpleMessage) { 98 const char normal_data[] = 99 "{\n" 100 " \"foo\": 1,\n" 101 " \"bar\": \"bar\",\n" 102 " \"baz\": true,\n" 103 " \"bstruct\": {},\n" 104 " \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}]," 105 " \"simple_enum\": \"foo\"," 106 " \"ints\": [1, 2]" 107 "}\n"; 108 109 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 110 SimpleMessage message; 111 base::JSONValueConverter<SimpleMessage> converter; 112 EXPECT_TRUE(converter.Convert(*value.get(), &message)); 113 114 EXPECT_EQ(1, message.foo); 115 EXPECT_EQ("bar", message.bar); 116 EXPECT_TRUE(message.baz); 117 EXPECT_EQ(SimpleMessage::FOO, message.simple_enum); 118 EXPECT_EQ(2, static_cast<int>(message.ints.size())); 119 ASSERT_EQ(2U, message.string_values.size()); 120 EXPECT_EQ("value_1", *message.string_values[0]); 121 EXPECT_EQ("value_2", *message.string_values[1]); 122 EXPECT_EQ(1, *(message.ints[0])); 123 EXPECT_EQ(2, *(message.ints[1])); 124 } 125 126 TEST(JSONValueConverterTest, ParseNestedMessage) { 127 const char normal_data[] = 128 "{\n" 129 " \"foo\": 1.0,\n" 130 " \"child\": {\n" 131 " \"foo\": 1,\n" 132 " \"bar\": \"bar\",\n" 133 " \"bstruct\": {},\n" 134 " \"string_values\": [{\"val\": \"value_1\"}, {\"val\": \"value_2\"}]," 135 " \"baz\": true\n" 136 " },\n" 137 " \"children\": [{\n" 138 " \"foo\": 2,\n" 139 " \"bar\": \"foobar\",\n" 140 " \"bstruct\": \"\",\n" 141 " \"string_values\": [{\"val\": \"value_1\"}]," 142 " \"baz\": true\n" 143 " },\n" 144 " {\n" 145 " \"foo\": 3,\n" 146 " \"bar\": \"barbaz\",\n" 147 " \"baz\": false\n" 148 " }]\n" 149 "}\n"; 150 151 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 152 NestedMessage message; 153 base::JSONValueConverter<NestedMessage> converter; 154 EXPECT_TRUE(converter.Convert(*value.get(), &message)); 155 156 EXPECT_EQ(1.0, message.foo); 157 EXPECT_EQ(1, message.child.foo); 158 EXPECT_EQ("bar", message.child.bar); 159 EXPECT_TRUE(message.child.baz); 160 EXPECT_TRUE(message.child.bstruct); 161 ASSERT_EQ(2U, message.child.string_values.size()); 162 EXPECT_EQ("value_1", *message.child.string_values[0]); 163 EXPECT_EQ("value_2", *message.child.string_values[1]); 164 165 EXPECT_EQ(2, static_cast<int>(message.children.size())); 166 const SimpleMessage* first_child = message.children[0]; 167 ASSERT_TRUE(first_child); 168 EXPECT_EQ(2, first_child->foo); 169 EXPECT_EQ("foobar", first_child->bar); 170 EXPECT_TRUE(first_child->baz); 171 EXPECT_TRUE(first_child->bstruct); 172 ASSERT_EQ(1U, first_child->string_values.size()); 173 EXPECT_EQ("value_1", *first_child->string_values[0]); 174 175 const SimpleMessage* second_child = message.children[1]; 176 ASSERT_TRUE(second_child); 177 EXPECT_EQ(3, second_child->foo); 178 EXPECT_EQ("barbaz", second_child->bar); 179 EXPECT_FALSE(second_child->baz); 180 EXPECT_FALSE(second_child->bstruct); 181 EXPECT_EQ(0U, second_child->string_values.size()); 182 } 183 184 TEST(JSONValueConverterTest, ParseFailures) { 185 const char normal_data[] = 186 "{\n" 187 " \"foo\": 1,\n" 188 " \"bar\": 2,\n" // "bar" is an integer here. 189 " \"baz\": true,\n" 190 " \"ints\": [1, 2]" 191 "}\n"; 192 193 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 194 SimpleMessage message; 195 base::JSONValueConverter<SimpleMessage> converter; 196 EXPECT_FALSE(converter.Convert(*value.get(), &message)); 197 // Do not check the values below. |message| may be modified during 198 // Convert() even it fails. 199 } 200 201 TEST(JSONValueConverterTest, ParseWithMissingFields) { 202 const char normal_data[] = 203 "{\n" 204 " \"foo\": 1,\n" 205 " \"baz\": true,\n" 206 " \"ints\": [1, 2]" 207 "}\n"; 208 209 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 210 SimpleMessage message; 211 base::JSONValueConverter<SimpleMessage> converter; 212 // Convert() still succeeds even if the input doesn't have "bar" field. 213 EXPECT_TRUE(converter.Convert(*value.get(), &message)); 214 215 EXPECT_EQ(1, message.foo); 216 EXPECT_TRUE(message.baz); 217 EXPECT_EQ(2, static_cast<int>(message.ints.size())); 218 EXPECT_EQ(1, *(message.ints[0])); 219 EXPECT_EQ(2, *(message.ints[1])); 220 } 221 222 TEST(JSONValueConverterTest, EnumParserFails) { 223 const char normal_data[] = 224 "{\n" 225 " \"foo\": 1,\n" 226 " \"bar\": \"bar\",\n" 227 " \"baz\": true,\n" 228 " \"simple_enum\": \"baz\"," 229 " \"ints\": [1, 2]" 230 "}\n"; 231 232 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 233 SimpleMessage message; 234 base::JSONValueConverter<SimpleMessage> converter; 235 EXPECT_FALSE(converter.Convert(*value.get(), &message)); 236 // No check the values as mentioned above. 237 } 238 239 TEST(JSONValueConverterTest, RepeatedValueErrorInTheMiddle) { 240 const char normal_data[] = 241 "{\n" 242 " \"foo\": 1,\n" 243 " \"bar\": \"bar\",\n" 244 " \"baz\": true,\n" 245 " \"simple_enum\": \"baz\"," 246 " \"ints\": [1, false]" 247 "}\n"; 248 249 std::unique_ptr<Value> value = base::JSONReader::Read(normal_data); 250 SimpleMessage message; 251 base::JSONValueConverter<SimpleMessage> converter; 252 EXPECT_FALSE(converter.Convert(*value.get(), &message)); 253 // No check the values as mentioned above. 254 } 255 256 } // namespace base 257
