third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/text_format_unittest.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 35 matching lines @@
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/testing/file.h>
 #include <google/protobuf/testing/file.h>
 #include <google/protobuf/test_util.h>
 #include <google/protobuf/unittest.pb.h>
 #include <google/protobuf/unittest_mset.pb.h>
 #include <google/protobuf/unittest_mset_wire_format.pb.h>
 #include <google/protobuf/io/tokenizer.h>
 #include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/stubs/mathlimits.h>
 #include <google/protobuf/stubs/strutil.h>
 #include <google/protobuf/stubs/substitute.h>
 #include <google/protobuf/testing/googletest.h>
 #include <gtest/gtest.h>
-#include <google/protobuf/stubs/mathlimits.h>
 
 
 namespace google {
 namespace protobuf {
 
 // Can't use an anonymous namespace here due to brokenness of Tru64 compiler.
 namespace text_format_unittest {
 
 // A basic string with different escapable characters for testing.
 const string kEscapeTestString =
@@ skipping 79 matching lines @@
   proto_.add_repeated_string("foo");
   proto_.add_repeated_string("bar");
   proto_.add_repeated_nested_message()->set_bb(2);
   proto_.add_repeated_nested_message()->set_bb(3);
   proto_.add_repeated_nested_enum(unittest::TestAllTypes::FOO);
   proto_.add_repeated_nested_enum(unittest::TestAllTypes::BAR);
 
   TextFormat::Printer printer;
   printer.SetUseShortRepeatedPrimitives(true);
   string text;
-  printer.PrintToString(proto_, &text);
+  EXPECT_TRUE(printer.PrintToString(proto_, &text));
 
   EXPECT_EQ("optional_int32: 123\n"
             "repeated_int32: [456, 789]\n"
+            "repeated_string: \"foo\"\n"
+            "repeated_string: \"bar\"\n"
+            "repeated_nested_message {\n  bb: 2\n}\n"
+            "repeated_nested_message {\n  bb: 3\n}\n"
+            "repeated_nested_enum: [FOO, BAR]\n",
+            text);
+
+  // Verify that any existing data in the string is cleared when
+  // PrintToString() is called.
+  text = "just some data here...\n\nblah blah";
+  EXPECT_TRUE(printer.PrintToString(proto_, &text));
+
+  EXPECT_EQ("optional_int32: 123\n"
+            "repeated_int32: [456, 789]\n"
             "repeated_string: \"foo\"\n"
             "repeated_string: \"bar\"\n"
             "repeated_nested_message {\n  bb: 2\n}\n"
             "repeated_nested_message {\n  bb: 3\n}\n"
             "repeated_nested_enum: [FOO, BAR]\n",
             text);
 
   // Try in single-line mode.
   printer.SetSingleLineMode(true);
-  printer.PrintToString(proto_, &text);
+  EXPECT_TRUE(printer.PrintToString(proto_, &text));
 
   EXPECT_EQ("optional_int32: 123 "
             "repeated_int32: [456, 789] "
             "repeated_string: \"foo\" "
             "repeated_string: \"bar\" "
             "repeated_nested_message { bb: 2 } "
             "repeated_nested_message { bb: 3 } "
             "repeated_nested_enum: [FOO, BAR] ",
             text);
 }
@@ skipping 468 matching lines @@
 
   ASSERT_EQ(2, proto_.repeated_nested_message_size());
   EXPECT_EQ(1, proto_.repeated_nested_message(0).bb());
   EXPECT_EQ(2, proto_.repeated_nested_message(1).bb());
 
   ASSERT_EQ(2, proto_.repeatedgroup_size());
   EXPECT_EQ(3, proto_.repeatedgroup(0).a());
   EXPECT_EQ(4, proto_.repeatedgroup(1).a());
 }
 
+TEST_F(TextFormatTest, ParseShortRepeatedWithTrailingComma) {
+  string parse_string = "repeated_int32: [456,]\n";
+  ASSERT_FALSE(TextFormat::ParseFromString(parse_string, &proto_));
+  parse_string = "repeated_nested_enum: [  FOO , ]";
+  ASSERT_FALSE(TextFormat::ParseFromString(parse_string, &proto_));
+  parse_string = "repeated_string: [ \"foo\", ]";
+  ASSERT_FALSE(TextFormat::ParseFromString(parse_string, &proto_));
+  parse_string = "repeated_nested_message: [ { bb: 1 }, ]";
+  ASSERT_FALSE(TextFormat::ParseFromString(parse_string, &proto_));
+  parse_string = "RepeatedGroup [{ a: 3 },]\n";
+}
+
+TEST_F(TextFormatTest, ParseShortRepeatedEmpty) {
+  string parse_string =
+      "repeated_int32: []\n"
+      "repeated_nested_enum: []\n"
+      "repeated_string: []\n"
+      "repeated_nested_message: []\n"
+      "RepeatedGroup []\n";
+
+  ASSERT_TRUE(TextFormat::ParseFromString(parse_string, &proto_));
+
+  EXPECT_EQ(0, proto_.repeated_int32_size());
+  EXPECT_EQ(0, proto_.repeated_nested_enum_size());
+  EXPECT_EQ(0, proto_.repeated_string_size());
+  EXPECT_EQ(0, proto_.repeated_nested_message_size());
+  EXPECT_EQ(0, proto_.repeatedgroup_size());
+}
+
+TEST_F(TextFormatTest, ParseShortRepeatedConcatenatedWithEmpty) {
+  string parse_string =
+      // Starting with empty [] should have no impact.
+      "repeated_int32: []\n"
+      "repeated_nested_enum: []\n"
+      "repeated_string: []\n"
+      "repeated_nested_message: []\n"
+      "RepeatedGroup []\n"
+      // Mixed short-form and long-form are simply concatenated.
+      "repeated_int32: 1\n"
+      "repeated_int32: [456, 789]\n"
+      "repeated_nested_enum: [  FOO ,BAR, # comment\n"
+      "                         3]\n"
+      // Note that while the printer won't print repeated strings in short-form,
+      // the parser will accept them.
+      "repeated_string: [ \"foo\", 'bar' ]\n"
+      // Repeated message
+      "repeated_nested_message: [ { bb: 1 }, { bb : 2 }]\n"
+      // Repeated group
+      "RepeatedGroup [{ a: 3 },{ a: 4 }]\n"
+      // Adding empty [] should have no impact.
+      "repeated_int32: []\n"
+      "repeated_nested_enum: []\n"
+      "repeated_string: []\n"
+      "repeated_nested_message: []\n"
+      "RepeatedGroup []\n";
+
+  ASSERT_TRUE(TextFormat::ParseFromString(parse_string, &proto_));
+
+  ASSERT_EQ(3, proto_.repeated_int32_size());
+  EXPECT_EQ(1, proto_.repeated_int32(0));
+  EXPECT_EQ(456, proto_.repeated_int32(1));
+  EXPECT_EQ(789, proto_.repeated_int32(2));
+
+  ASSERT_EQ(3, proto_.repeated_nested_enum_size());
+  EXPECT_EQ(unittest::TestAllTypes::FOO, proto_.repeated_nested_enum(0));
+  EXPECT_EQ(unittest::TestAllTypes::BAR, proto_.repeated_nested_enum(1));
+  EXPECT_EQ(unittest::TestAllTypes::BAZ, proto_.repeated_nested_enum(2));
+
+  ASSERT_EQ(2, proto_.repeated_string_size());
+  EXPECT_EQ("foo", proto_.repeated_string(0));
+  EXPECT_EQ("bar", proto_.repeated_string(1));
+
+  ASSERT_EQ(2, proto_.repeated_nested_message_size());
+  EXPECT_EQ(1, proto_.repeated_nested_message(0).bb());
+  EXPECT_EQ(2, proto_.repeated_nested_message(1).bb());
+
+  ASSERT_EQ(2, proto_.repeatedgroup_size());
+  EXPECT_EQ(3, proto_.repeatedgroup(0).a());
+  EXPECT_EQ(4, proto_.repeatedgroup(1).a());
+}
+
 
 TEST_F(TextFormatTest, Comments) {
   // Test that comments are ignored.
 
   string parse_string = "optional_int32: 1  # a comment\n"
                         "optional_int64: 2  # another comment";
 
   io::ArrayInputStream input_stream(parse_string.data(),
                                     parse_string.size());
 
@@ skipping 517 matching lines @@
 
 #undef EXPECT_FIELD
 #undef EXPECT_BOOL_FIELD
 #undef EXPECT_FLOAT_FIELD
 #undef EXPECT_DOUBLE_FIELD
 #undef EXPECT_INVALID
 }
 
 
 TEST_F(TextFormatParserTest, InvalidToken) {
-  ExpectFailure("optional_bool: true\n-5\n", "Expected identifier.",
+  ExpectFailure("optional_bool: true\n-5\n", "Expected identifier, got: -",
                 2, 1);
 
-  ExpectFailure("optional_bool: true!\n", "Expected identifier.", 1, 20);
-  ExpectFailure("\"some string\"", "Expected identifier.", 1, 1);
+  ExpectFailure("optional_bool: true!\n", "Expected identifier, got: !", 1,
+                20);
+  ExpectFailure("\"some string\"",
+                "Expected identifier, got: \"some string\"", 1, 1);
 }
 
 TEST_F(TextFormatParserTest, InvalidFieldName) {
   ExpectFailure(
       "invalid_field: somevalue\n",
       "Message type \"protobuf_unittest.TestAllTypes\" has no field named "
       "\"invalid_field\".",
       1, 14);
 }
 
@@ skipping 27 matching lines @@
   // ... but are parsed correctly if we match case insensitive.
   parser.AllowCaseInsensitiveField(true);
   EXPECT_TRUE(parser.ParseFromString("Optional_Double: 10.0", &proto));
   EXPECT_EQ(10.0, proto.optional_double());
   EXPECT_TRUE(parser.ParseFromString("oPtIoNaLgRoUp { a: 15 }", &proto));
   EXPECT_EQ(15, proto.optionalgroup().a());
 }
 
 TEST_F(TextFormatParserTest, InvalidFieldValues) {
   // Invalid values for a double/float field.
-  ExpectFailure("optional_double: \"hello\"\n", "Expected double.", 1, 18);
-  ExpectFailure("optional_double: true\n", "Expected double.", 1, 18);
-  ExpectFailure("optional_double: !\n", "Expected double.", 1, 18);
+  ExpectFailure("optional_double: \"hello\"\n",
+                "Expected double, got: \"hello\"", 1, 18);
+  ExpectFailure("optional_double: true\n", "Expected double, got: true", 1,
+                18);
+  ExpectFailure("optional_double: !\n", "Expected double, got: !", 1, 18);
   ExpectFailure("optional_double {\n  \n}\n", "Expected \":\", found \"{\".",
                 1, 17);
 
   // Invalid values for a signed integer field.
-  ExpectFailure("optional_int32: \"hello\"\n", "Expected integer.", 1, 17);
-  ExpectFailure("optional_int32: true\n", "Expected integer.", 1, 17);
-  ExpectFailure("optional_int32: 4.5\n", "Expected integer.", 1, 17);
-  ExpectFailure("optional_int32: !\n", "Expected integer.", 1, 17);
+  ExpectFailure("optional_int32: \"hello\"\n",
+                "Expected integer, got: \"hello\"", 1, 17);
+  ExpectFailure("optional_int32: true\n", "Expected integer, got: true", 1, 17);
+  ExpectFailure("optional_int32: 4.5\n", "Expected integer, got: 4.5", 1, 17);
+  ExpectFailure("optional_int32: !\n", "Expected integer, got: !", 1, 17);
   ExpectFailure("optional_int32 {\n \n}\n", "Expected \":\", found \"{\".",
                 1, 16);
   ExpectFailure("optional_int32: 0x80000000\n",
-                "Integer out of range.", 1, 17);
+                "Integer out of range (0x80000000)", 1, 17);
   ExpectFailure("optional_int64: 0x8000000000000000\n",
-                "Integer out of range.", 1, 17);
+                "Integer out of range (0x8000000000000000)", 1, 17);
   ExpectFailure("optional_int32: -0x80000001\n",
-                "Integer out of range.", 1, 18);
+                "Integer out of range (0x80000001)", 1, 18);
   ExpectFailure("optional_int64: -0x8000000000000001\n",
-                "Integer out of range.", 1, 18);
+                "Integer out of range (0x8000000000000001)", 1, 18);
 
   // Invalid values for an unsigned integer field.
-  ExpectFailure("optional_uint64: \"hello\"\n", "Expected integer.", 1, 18);
-  ExpectFailure("optional_uint64: true\n", "Expected integer.", 1, 18);
-  ExpectFailure("optional_uint64: 4.5\n", "Expected integer.", 1, 18);
-  ExpectFailure("optional_uint64: -5\n", "Expected integer.", 1, 18);
-  ExpectFailure("optional_uint64: !\n", "Expected integer.", 1, 18);
+  ExpectFailure("optional_uint64: \"hello\"\n",
+                "Expected integer, got: \"hello\"", 1, 18);
+  ExpectFailure("optional_uint64: true\n",
+                "Expected integer, got: true", 1, 18);
+  ExpectFailure("optional_uint64: 4.5\n", "Expected integer, got: 4.5", 1, 18);
+  ExpectFailure("optional_uint64: -5\n", "Expected integer, got: -", 1, 18);
+  ExpectFailure("optional_uint64: !\n", "Expected integer, got: !", 1, 18);
   ExpectFailure("optional_uint64 {\n \n}\n", "Expected \":\", found \"{\".",
                 1, 17);
   ExpectFailure("optional_uint32: 0x100000000\n",
-                "Integer out of range.", 1, 18);
+                "Integer out of range (0x100000000)", 1, 18);
   ExpectFailure("optional_uint64: 0x10000000000000000\n",
-                "Integer out of range.", 1, 18);
+                "Integer out of range (0x10000000000000000)", 1, 18);
 
   // Invalid values for a boolean field.
-  ExpectFailure("optional_bool: \"hello\"\n", "Expected identifier.", 1, 16);
-  ExpectFailure("optional_bool: 5\n", "Integer out of range.", 1, 16);
-  ExpectFailure("optional_bool: -7.5\n", "Expected identifier.", 1, 16);
-  ExpectFailure("optional_bool: !\n", "Expected identifier.", 1, 16);
+  ExpectFailure("optional_bool: \"hello\"\n",
+                "Expected identifier, got: \"hello\"", 1, 16);
+  ExpectFailure("optional_bool: 5\n", "Integer out of range (5)", 1, 16);
+  ExpectFailure("optional_bool: -7.5\n", "Expected identifier, got: -", 1, 16);
+  ExpectFailure("optional_bool: !\n", "Expected identifier, got: !", 1, 16);
 
   ExpectFailure(
       "optional_bool: meh\n",
       "Invalid value for boolean field \"optional_bool\". Value: \"meh\".",
       2, 1);
 
   ExpectFailure("optional_bool {\n \n}\n", "Expected \":\", found \"{\".",
                 1, 15);
 
   // Invalid values for a string field.
-  ExpectFailure("optional_string: true\n", "Expected string.", 1, 18);
-  ExpectFailure("optional_string: 5\n", "Expected string.", 1, 18);
-  ExpectFailure("optional_string: -7.5\n", "Expected string.", 1, 18);
-  ExpectFailure("optional_string: !\n", "Expected string.", 1, 18);
+  ExpectFailure("optional_string: true\n", "Expected string, got: true", 1, 18);
+  ExpectFailure("optional_string: 5\n", "Expected string, got: 5", 1, 18);
+  ExpectFailure("optional_string: -7.5\n", "Expected string, got: -", 1, 18);
+  ExpectFailure("optional_string: !\n", "Expected string, got: !", 1, 18);
   ExpectFailure("optional_string {\n \n}\n", "Expected \":\", found \"{\".",
                 1, 17);
 
   // Invalid values for an enumeration field.
   ExpectFailure("optional_nested_enum: \"hello\"\n",
-                "Expected integer or identifier.", 1, 23);
+                "Expected integer or identifier, got: \"hello\"", 1, 23);
 
   // Valid token, but enum value is not defined.
   ExpectFailure("optional_nested_enum: 5\n",
                 "Unknown enumeration value of \"5\" for field "
                 "\"optional_nested_enum\".", 2, 1);
   // We consume the negative sign, so the error position starts one character
   // later.
-  ExpectFailure("optional_nested_enum: -7.5\n", "Expected integer.", 1, 24);
+  ExpectFailure("optional_nested_enum: -7.5\n", "Expected integer, got: 7.5", 1,
+                24);
   ExpectFailure("optional_nested_enum: !\n",
-                "Expected integer or identifier.", 1, 23);
+                "Expected integer or identifier, got: !", 1, 23);
 
   ExpectFailure(
       "optional_nested_enum: grah\n",
       "Unknown enumeration value of \"grah\" for field "
       "\"optional_nested_enum\".", 2, 1);
 
   ExpectFailure(
       "optional_nested_enum {\n \n}\n",
       "Expected \":\", found \"{\".", 1, 22);
 }
 
 TEST_F(TextFormatParserTest, MessageDelimiters) {
   // Non-matching delimiters.
   ExpectFailure("OptionalGroup <\n \n}\n", "Expected \">\", found \"}\".",
                 3, 1);
 
   // Invalid delimiters.
   ExpectFailure("OptionalGroup [\n \n]\n", "Expected \"{\", found \"[\".",
                 1, 15);
 
   // Unending message.
   ExpectFailure("optional_nested_message {\n \nbb: 118\n",
-                "Expected identifier.",
+                "Expected identifier, got: ",
                 4, 1);
 }
 
 TEST_F(TextFormatParserTest, UnknownExtension) {
   // Non-matching delimiters.
   ExpectFailure("[blahblah]: 123",
                 "Extension \"blahblah\" is not defined or is not an "
                 "extension of \"protobuf_unittest.TestAllTypes\".",
                 1, 11);
 }
@@ skipping 121 matching lines @@
   vector<const FieldDescriptor*> descriptors;
   proto.message_set().GetReflection()->ListFields(
     proto.message_set(), &descriptors);
   EXPECT_EQ(2, descriptors.size());
 }
 
 
 }  // namespace text_format_unittest
 }  // namespace protobuf
 }  // namespace google