third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/json_stream_parser_test.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 63 matching lines @@
 // - mismatched object and array closing
 // - Failure to close array or object
 // - numbers too large
 // - invalid unicode escapes.
 // - invalid unicode sequences.
 // - numbers as keys
 //
 // For each test we split the input string on every possible character to ensure
 // the parser is able to handle arbitrarily split input for all cases. We also
 // do a final test of the entire test case one character at a time.
+//
+// It is verified that expected calls to the mocked objects are in sequence.
 class JsonStreamParserTest : public ::testing::Test {
  protected:
   JsonStreamParserTest() : mock_(), ow_(&mock_) {}
   virtual ~JsonStreamParserTest() {}
 
-  util::Status RunTest(StringPiece json, int split, bool coerce_utf8 = false) {
+  util::Status RunTest(StringPiece json, int split, bool coerce_utf8 = false,
+                       bool allow_empty_null = false,
+                       bool loose_float_number_conversion = false) {
     JsonStreamParser parser(&mock_);
 
     // Special case for split == length, test parsing one character at a time.
     if (split == json.length()) {
       GOOGLE_LOG(INFO) << "Testing split every char: " << json;
       for (int i = 0; i < json.length(); ++i) {
         StringPiece single = json.substr(i, 1);
         util::Status result = parser.Parse(single);
         if (!result.ok()) {
           return result;
         }
       }
       return parser.FinishParse();
     }
 
     // Normal case, split at the split point and parse two substrings.
     StringPiece first = json.substr(0, split);
     StringPiece rest = json.substr(split);
     GOOGLE_LOG(INFO) << "Testing split: " << first << "><" << rest;
     util::Status result = parser.Parse(first);
     if (result.ok()) {
       result = parser.Parse(rest);
       if (result.ok()) {
         result = parser.FinishParse();
       }
     }
     return result;
   }
 
-  void DoTest(StringPiece json, int split, bool coerce_utf8 = false) {
-    util::Status result = RunTest(json, split, coerce_utf8);
+  void DoTest(StringPiece json, int split, bool coerce_utf8 = false,
+              bool allow_empty_null = false,
+              bool loose_float_number_conversion = false) {
+    util::Status result = RunTest(json, split, coerce_utf8, allow_empty_null,
+                                  loose_float_number_conversion);
     if (!result.ok()) {
       GOOGLE_LOG(WARNING) << result;
     }
     EXPECT_OK(result);
   }
 
   void DoErrorTest(StringPiece json, int split, StringPiece error_prefix,
-                   bool coerce_utf8 = false) {
-    util::Status result = RunTest(json, split, coerce_utf8);
+                   bool coerce_utf8 = false, bool allow_empty_null = false) {
+    util::Status result =
+        RunTest(json, split, coerce_utf8, allow_empty_null);
     EXPECT_EQ(util::error::INVALID_ARGUMENT, result.error_code());
     StringPiece error_message(result.error_message());
     EXPECT_EQ(error_prefix, error_message.substr(0, error_prefix.size()));
   }
 
 
+#ifndef _MSC_VER
+  // TODO(xiaofeng): We have to disable InSequence check for MSVC because it
+  // causes stack overflow due to its use of a linked list that is desctructed
+  // recursively.
+  ::testing::InSequence in_sequence_;
+#endif  // !_MSC_VER
   MockObjectWriter mock_;
   ExpectingObjectWriter ow_;
 };
 
 
 // Positive tests
 
 // - true, false, null
 TEST_F(JsonStreamParserTest, SimpleTrue) {
   StringPiece str = "true";
@@ skipping 155 matching lines @@
         ->RenderNull("key")
         ->StartList("snake_key")
         ->EndList()
         ->StartObject("camelKey")
         ->EndObject()
         ->EndObject();
     DoTest(str, i);
   }
 }
 
-// - array containing array, object, values (true, false, null, num, string)
-TEST_F(JsonStreamParserTest, ArrayValues) {
-  StringPiece str =
-      "[true, false, null, 'a string', \"another string\", [22, -127, 45.3, "
-      "-1056.4, 11779497823553162765], {'key': true}]";
+// - array containing primitive values (true, false, null, num, string)
+TEST_F(JsonStreamParserTest, ArrayPrimitiveValues) {
+  StringPiece str = "[true, false, null, 'one', \"two\"]";
   for (int i = 0; i <= str.length(); ++i) {
     ow_.StartList("")
         ->RenderBool("", true)
         ->RenderBool("", false)
         ->RenderNull("")
-        ->RenderString("", "a string")
-        ->RenderString("", "another string")
+        ->RenderString("", "one")
+        ->RenderString("", "two")
+        ->EndList();
+    DoTest(str, i);
+  }
+}
+
+// - array containing array, object
+TEST_F(JsonStreamParserTest, ArrayComplexValues) {
+  StringPiece str =
+      "[[22, -127, 45.3, -1056.4, 11779497823553162765], {'key': true}]";
+  for (int i = 0; i <= str.length(); ++i) {
+    ow_.StartList("")
         ->StartList("")
         ->RenderUint64("", 22)
         ->RenderInt64("", -127)
         ->RenderDouble("", 45.3)
         ->RenderDouble("", -1056.4)
         ->RenderUint64("", 11779497823553162765ULL)
         ->EndList()
         ->StartObject("")
         ->RenderBool("key", true)
         ->EndObject()
         ->EndList();
     DoTest(str, i);
   }
 }
 
+
 // - object containing array, object, value (true, false, null, num, string)
 TEST_F(JsonStreamParserTest, ObjectValues) {
   StringPiece str =
       "{t: true, f: false, n: null, s: 'a string', d: \"another string\", pi: "
       "22, ni: -127, pd: 45.3, nd: -1056.4, pl: 11779497823553162765, l: [[]], "
       "o: {'key': true}}";
   for (int i = 0; i <= str.length(); ++i) {
     ow_.StartObject("")
         ->RenderBool("t", true)
         ->RenderBool("f", false)
@@ skipping 332 matching lines @@
 }
 
 TEST_F(JsonStreamParserTest, NegativeNumberTooBig) {
   StringPiece str = "[-18446744073709551616]";
   for (int i = 0; i <= str.length(); ++i) {
     ow_.StartList("");
     DoErrorTest(str, i, "Unable to parse number.");
   }
 }
 
-/*
-TODO(sven): Fail parsing when parsing a double that is too large.
-
 TEST_F(JsonStreamParserTest, DoubleTooBig) {
-  StringPiece str = "[184464073709551232321616.45]";
+  StringPiece str = "[1.89769e+308]";
   for (int i = 0; i <= str.length(); ++i) {
     ow_.StartList("");
-    DoErrorTest(str, i, "Unable to parse number");
+    DoErrorTest(str, i, "Number exceeds the range of double.");
+  }
+  str = "[-1.89769e+308]";
+  for (int i = 0; i <= str.length(); ++i) {
+    ow_.StartList("");
+    DoErrorTest(str, i, "Number exceeds the range of double.");
   }
 }
-*/
+
 
 // invalid bare backslash.
 TEST_F(JsonStreamParserTest, UnfinishedEscape) {
   StringPiece str = "\"\\";
   for (int i = 0; i <= str.length(); ++i) {
     DoErrorTest(str, i, "Closing quote expected in string.");
   }
 }
 
 // invalid bare backslash u.
@@ skipping 99 matching lines @@
   for (int i = 0; i <= str.length(); ++i) {
     ow_.StartObject("");
     DoErrorTest(str, i, "Expected a value.");
   }
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google