base/json/json_value_converter_unittest.cc

   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 <string>
   8 #include <vector>
   9
  10 #include "base/json/json_reader.h"
  11 #include "base/memory/scoped_ptr.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   scoped_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   scoped_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   scoped_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   scoped_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   scoped_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   scoped_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