third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/protostream_objectwriter_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 23 matching lines @@
 
 #include <google/protobuf/field_mask.pb.h>
 #include <google/protobuf/timestamp.pb.h>
 #include <google/protobuf/wrappers.pb.h>
 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/dynamic_message.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/util/internal/mock_error_listener.h>
+#include <google/protobuf/util/internal/testdata/anys.pb.h>
 #include <google/protobuf/util/internal/testdata/books.pb.h>
 #include <google/protobuf/util/internal/testdata/field_mask.pb.h>
+#include <google/protobuf/util/internal/testdata/maps.pb.h>
+#include <google/protobuf/util/internal/testdata/oneofs.pb.h>
+#include <google/protobuf/util/internal/testdata/proto3.pb.h>
+#include <google/protobuf/util/internal/testdata/struct.pb.h>
+#include <google/protobuf/util/internal/testdata/timestamp_duration.pb.h>
+#include <google/protobuf/util/internal/testdata/wrappers.pb.h>
 #include <google/protobuf/util/internal/type_info_test_helper.h>
 #include <google/protobuf/util/internal/constants.h>
 #include <google/protobuf/util/message_differencer.h>
 #include <google/protobuf/stubs/bytestream.h>
 #include <google/protobuf/stubs/strutil.h>
-#include <google/protobuf/util/internal/testdata/anys.pb.h>
-#include <google/protobuf/util/internal/testdata/maps.pb.h>
-#include <google/protobuf/util/internal/testdata/oneofs.pb.h>
-#include <google/protobuf/util/internal/testdata/struct.pb.h>
-#include <google/protobuf/util/internal/testdata/timestamp_duration.pb.h>
 #include <gtest/gtest.h>
 
 
 namespace google {
 namespace protobuf {
 namespace util {
 namespace converter {
 
+using google::protobuf::testing::AnyM;
+using google::protobuf::testing::AnyOut;
 using google::protobuf::testing::Author;
 using google::protobuf::testing::Book;
-using google::protobuf::testing::Book_Data;
+using google::protobuf::testing::FieldMaskTest;
+using google::protobuf::testing::Int32Wrapper;
+using google::protobuf::testing::MapIn;
 using google::protobuf::testing::Primitive;
+using google::protobuf::testing::Proto3Message;
 using google::protobuf::testing::Publisher;
+using google::protobuf::testing::StructType;
+using google::protobuf::testing::TimestampDuration;
+using google::protobuf::testing::ValueWrapper;
+using google::protobuf::testing::oneofs::OneOfsRequest;
 using google::protobuf::Descriptor;
 using google::protobuf::DescriptorPool;
 using google::protobuf::DynamicMessageFactory;
 using google::protobuf::FileDescriptorProto;
 using google::protobuf::Message;
-using google::protobuf::io::ArrayInputStream;
 using strings::GrowingArrayByteSink;
 using ::testing::_;
 using ::testing::Args;
-using google::protobuf::testing::anys::AnyM;
-using google::protobuf::testing::anys::AnyOut;
-using google::protobuf::testing::oneofs::OneOfsRequest;
-using google::protobuf::testing::FieldMaskTest;
-using google::protobuf::testing::maps::MapIn;
-using google::protobuf::testing::structs::StructType;
-using google::protobuf::testing::timestampduration::TimestampDuration;
 
 
 namespace {
 string GetTypeUrl(const Descriptor* descriptor) {
   return string(kTypeServiceBaseUrl) + "/" + descriptor->full_name();
 }
 }  // namespace
 
 #if __cplusplus >= 201103L
   using std::get;
 #else
   using std::tr1::get;
 #endif
 
 class BaseProtoStreamObjectWriterTest
     : public ::testing::TestWithParam<testing::TypeInfoSource> {
  protected:
   BaseProtoStreamObjectWriterTest()
       : helper_(GetParam()),
         listener_(),
         output_(new GrowingArrayByteSink(1000)),
         ow_() {}
 
   explicit BaseProtoStreamObjectWriterTest(const Descriptor* descriptor)
       : helper_(GetParam()),
         listener_(),
         output_(new GrowingArrayByteSink(1000)),
         ow_() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(descriptor);
     ResetTypeInfo(descriptors);
   }
 
   explicit BaseProtoStreamObjectWriterTest(
-      vector<const Descriptor*> descriptors)
+      std::vector<const Descriptor*> descriptors)
       : helper_(GetParam()),
         listener_(),
         output_(new GrowingArrayByteSink(1000)),
         ow_() {
     ResetTypeInfo(descriptors);
   }
 
-  void ResetTypeInfo(vector<const Descriptor*> descriptors) {
+  void ResetTypeInfo(std::vector<const Descriptor*> descriptors) {
     GOOGLE_CHECK(!descriptors.empty()) << "Must have at least one descriptor!";
     helper_.ResetTypeInfo(descriptors);
     ow_.reset(helper_.NewProtoWriter(GetTypeUrl(descriptors[0]), output_.get(),
                                      &listener_, options_));
   }
 
   void ResetTypeInfo(const Descriptor* descriptor) {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(descriptor);
     ResetTypeInfo(descriptors);
   }
 
   virtual ~BaseProtoStreamObjectWriterTest() {}
 
   void CheckOutput(const Message& expected, int expected_length) {
     size_t nbytes;
     google::protobuf::scoped_array<char> buffer(output_->GetBuffer(&nbytes));
     if (expected_length >= 0) {
@@ skipping 30 matching lines @@
   if (actual.compare(expected) == 0) return true;
   *result_listener << "actual location is: " << actual;
   return false;
 }
 
 class ProtoStreamObjectWriterTest : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterTest()
       : BaseProtoStreamObjectWriterTest(Book::descriptor()) {}
 
+  void ResetProtoWriter() {
+    ResetTypeInfo(Book::descriptor());
+  }
+
   virtual ~ProtoStreamObjectWriterTest() {}
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
 
 TEST_P(ProtoStreamObjectWriterTest, EmptyObject) {
   Book empty;
@@ skipping 61 matching lines @@
 
   ow_->StartObject("")
       ->StartObject("author")
       ->RenderUint64("@id", 12345)
       ->RenderString("name", "robert")
       ->EndObject()
       ->EndObject();
   CheckOutput(book);
 }
 
+TEST_P(ProtoStreamObjectWriterTest, IntEnumValuesAreAccepted) {
+  Book book;
+  book.set_title("Some Book");
+  book.set_type(google::protobuf::testing::Book_Type_KIDS);
+  Author* robert = book.mutable_author();
+  robert->set_name("robert");
+
+  ow_->StartObject("")
+      ->RenderString("title", "Some Book")
+      ->RenderString("type", "2")
+      ->StartObject("author")
+      ->RenderString("name", "robert")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(book);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, EnumValuesWithoutUnderscoreAreAccepted) {
+  Book book;
+  book.set_title("Some Book");
+  book.set_type(google::protobuf::testing::Book_Type_ACTION_AND_ADVENTURE);
+  Author* robert = book.mutable_author();
+  robert->set_name("robert");
+
+  options_.use_lower_camel_for_enums = true;
+  ResetProtoWriter();
+
+  ow_->StartObject("")
+      ->RenderString("title", "Some Book")
+      ->RenderString("type", "ACTIONANDADVENTURE")
+      ->StartObject("author")
+      ->RenderString("name", "robert")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(book);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, EnumValuesInCamelCaseAreAccepted) {
+  Book book;
+  book.set_title("Some Book");
+  book.set_type(google::protobuf::testing::Book_Type_ACTION_AND_ADVENTURE);
+  Author* robert = book.mutable_author();
+  robert->set_name("robert");
+
+  options_.use_lower_camel_for_enums = true;
+  ResetProtoWriter();
+
+  ow_->StartObject("")
+      ->RenderString("title", "Some Book")
+      ->RenderString("type", "actionAndAdventure")
+      ->StartObject("author")
+      ->RenderString("name", "robert")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(book);
+}
+
+TEST_P(ProtoStreamObjectWriterTest,
+       EnumValuesInCamelCaseWithNameNotUppercaseAreAccepted) {
+  Book book;
+  book.set_title("Some Book");
+  book.set_type(google::protobuf::testing::Book_Type_arts_and_photography);
+  Author* robert = book.mutable_author();
+  robert->set_name("robert");
+
+  options_.use_lower_camel_for_enums = true;
+  ResetProtoWriter();
+
+  ow_->StartObject("")
+      ->RenderString("title", "Some Book")
+      ->RenderString("type", "artsAndPhotography")
+      ->StartObject("author")
+      ->RenderString("name", "robert")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(book);
+}
+
 TEST_P(ProtoStreamObjectWriterTest, PrimitiveFromStringConversion) {
   Primitive full;
   full.set_fix32(101);
   full.set_u32(102);
   full.set_i32(-103);
   full.set_sf32(-104);
   full.set_s32(-105);
   full.set_fix64(40000000001L);
   full.set_u64(40000000002L);
   full.set_i64(-40000000003L);
@@ skipping 425 matching lines @@
       ->StartObject("publisher")
       ->RenderString("name", "propaganda")
       ->StartList("alliance")
       ->EndList()
       ->EndObject()
       ->RenderString("title", "Brainwashing")
       ->EndObject();
   CheckOutput(expected);
 }
 
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownFieldAtRoot) {
+  Book empty;
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")->RenderString("unknown", "Nope!")->EndObject();
+  CheckOutput(empty, 0);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownFieldAtAuthorFriend) {
+  Book expected;
+  Author* paul = expected.mutable_author();
+  paul->set_name("Paul");
+  Author* mark = paul->add_friend_();
+  mark->set_name("Mark");
+  Author* john = paul->add_friend_();
+  john->set_name("John");
+  Author* luke = paul->add_friend_();
+  luke->set_name("Luke");
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("author")
+      ->RenderString("name", "Paul")
+      ->StartList("friend")
+      ->StartObject("")
+      ->RenderString("name", "Mark")
+      ->EndObject()
+      ->StartObject("")
+      ->RenderString("name", "John")
+      ->RenderString("address", "Patmos")
+      ->EndObject()
+      ->StartObject("")
+      ->RenderString("name", "Luke")
+      ->EndObject()
+      ->EndList()
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(expected);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownObjectAtRoot) {
+  Book empty;
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, StringPiece("unknown"),
+                                     StringPiece("Cannot find field.")))
+      .Times(0);
+  ow_->StartObject("")->StartObject("unknown")->EndObject()->EndObject();
+  CheckOutput(empty, 0);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownObjectAtAuthor) {
+  Book expected;
+  Author* author = expected.mutable_author();
+  author->set_name("William");
+  author->add_pseudonym("Bill");
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("author")
+      ->RenderString("name", "William")
+      ->StartObject("wife")
+      ->RenderString("name", "Hilary")
+      ->EndObject()
+      ->RenderString("pseudonym", "Bill")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(expected);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownListAtRoot) {
+  Book empty;
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")->StartList("unknown")->EndList()->EndObject();
+  CheckOutput(empty, 0);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, IgnoreUnknownListAtPublisher) {
+  Book expected;
+  expected.set_title("Brainwashing");
+  Publisher* publisher = expected.mutable_publisher();
+  publisher->set_name("propaganda");
+
+  options_.ignore_unknown_fields = true;
+  ResetProtoWriter();
+
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("publisher")
+      ->RenderString("name", "propaganda")
+      ->StartList("alliance")
+      ->EndList()
+      ->EndObject()
+      ->RenderString("title", "Brainwashing")
+      ->EndObject();
+  CheckOutput(expected);
+}
+
+TEST_P(ProtoStreamObjectWriterTest, AcceptUnknownEnumValue) {
+  ResetTypeInfo(Proto3Message::descriptor());
+
+  Proto3Message expected;
+  expected.set_enum_value(static_cast<Proto3Message::NestedEnum>(12345));
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->RenderInt32("enumValue", 12345)
+      ->EndObject();
+  CheckOutput(expected);
+}
+
 TEST_P(ProtoStreamObjectWriterTest, MissingRequiredField) {
   Book expected;
   expected.set_title("My Title");
   expected.set_allocated_publisher(new Publisher());
 
   EXPECT_CALL(listener_, MissingField(_, StringPiece("name")))
       .With(Args<0>(HasObjectLocation("publisher")));
   ow_->StartObject("")
       ->StartObject("publisher")
       ->EndObject()
@@ skipping 138 matching lines @@
   Book empty;
 
   ow_->RenderNull("length");
   CheckOutput(empty, 0);
 }
 
 class ProtoStreamObjectWriterTimestampDurationTest
     : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterTimestampDurationTest() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(TimestampDuration::descriptor());
     descriptors.push_back(google::protobuf::Timestamp::descriptor());
     descriptors.push_back(google::protobuf::Duration::descriptor());
     ResetTypeInfo(descriptors);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterTimestampDurationTest,
                         ::testing::Values(
@@ skipping 333 matching lines @@
 }
 
 TEST_P(ProtoStreamObjectWriterTimestampDurationTest,
        MismatchedTimestampTypeInput) {
   TimestampDuration timestamp;
   EXPECT_CALL(
       listener_,
       InvalidValue(
           _, StringPiece("type.googleapis.com/google.protobuf.Timestamp"),
           StringPiece(
-              "Field 'ts', Invalid data type for timestamp, value is null")))
+              "Field 'ts', Invalid data type for timestamp, value is 1")))
       .With(Args<0>(HasObjectLocation("ts")));
-  ow_->StartObject("")->RenderNull("ts")->EndObject();
+  ow_->StartObject("")->RenderInt32("ts", 1)->EndObject();
   CheckOutput(timestamp);
 }
 
 TEST_P(ProtoStreamObjectWriterTimestampDurationTest,
        MismatchedDurationTypeInput) {
   TimestampDuration duration;
   EXPECT_CALL(
       listener_,
       InvalidValue(
           _, StringPiece("type.googleapis.com/google.protobuf.Duration"),
           StringPiece(
-              "Field 'dur', Invalid data type for duration, value is null")))
+              "Field 'dur', Invalid data type for duration, value is 1")))
       .With(Args<0>(HasObjectLocation("dur")));
+  ow_->StartObject("")->RenderInt32("dur", 1)->EndObject();
+  CheckOutput(duration);
+}
+
+TEST_P(ProtoStreamObjectWriterTimestampDurationTest, TimestampAcceptsNull) {
+  TimestampDuration timestamp;
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")->RenderNull("ts")->EndObject();
+  CheckOutput(timestamp);
+}
+
+TEST_P(ProtoStreamObjectWriterTimestampDurationTest, DurationAcceptsNull) {
+  TimestampDuration duration;
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
   ow_->StartObject("")->RenderNull("dur")->EndObject();
   CheckOutput(duration);
 }
 
 class ProtoStreamObjectWriterStructTest
     : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterStructTest() { ResetProtoWriter(); }
 
   // Resets ProtoWriter with current set of options and other state.
   void ResetProtoWriter() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(StructType::descriptor());
     descriptors.push_back(google::protobuf::Struct::descriptor());
     ResetTypeInfo(descriptors);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterStructTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
@@ skipping 29 matching lines @@
   EXPECT_CALL(
       listener_,
       InvalidValue(_, StringPiece("type.googleapis.com/google.protobuf.Struct"),
                    StringPiece("true")))
       .With(Args<0>(HasObjectLocation("object")));
 
   ow_->StartObject("")->RenderBool("object", true)->EndObject();
   CheckOutput(struct_type);
 }
 
+TEST_P(ProtoStreamObjectWriterStructTest, StructAcceptsNull) {
+  StructType struct_type;
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+
+  ow_->StartObject("")->RenderNull("object")->EndObject();
+  CheckOutput(struct_type);
+}
+
+TEST_P(ProtoStreamObjectWriterStructTest, StructValuePreservesNull) {
+  StructType struct_type;
+  (*struct_type.mutable_object()->mutable_fields())["key"].set_null_value(
+      google::protobuf::NULL_VALUE);
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+
+  ow_->StartObject("")
+      ->StartObject("object")
+      ->RenderNull("key")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(struct_type);
+}
+
 TEST_P(ProtoStreamObjectWriterStructTest, SimpleRepeatedStructMapKeyTest) {
   EXPECT_CALL(
       listener_,
       InvalidName(_, StringPiece("gBike"),
                   StringPiece("Repeated map key: 'gBike' is already set.")));
   ow_->StartObject("")
       ->StartObject("object")
       ->RenderString("gBike", "v1")
       ->RenderString("gBike", "v2")
       ->EndObject()
@@ skipping 47 matching lines @@
       ->StartObject("object")
       ->RenderDouble("k1", 123)
       ->RenderBool("k2", true)
       ->RenderInt64("k3", -222222222)
       ->RenderUint64("k4", 33333333)
       ->EndObject()
       ->EndObject();
   CheckOutput(struct_type);
 }
 
+TEST_P(ProtoStreamObjectWriterStructTest, ValuePreservesNull) {
+  ValueWrapper value;
+  value.mutable_value()->set_null_value(google::protobuf::NULL_VALUE);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")->RenderNull("value")->EndObject();
+  CheckOutput(value);
+}
+
 class ProtoStreamObjectWriterMapTest : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterMapTest()
       : BaseProtoStreamObjectWriterTest(MapIn::descriptor()) {}
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterMapTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
@@ skipping 23 matching lines @@
       ->StartObject("map_input")
       ->RenderString("k1", "v1")
       ->RenderString("k1", "v2")
       ->EndObject()
       ->EndObject();
 }
 
 class ProtoStreamObjectWriterAnyTest : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterAnyTest() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(AnyOut::descriptor());
+    descriptors.push_back(Book::descriptor());
+    descriptors.push_back(google::protobuf::Any::descriptor());
     descriptors.push_back(google::protobuf::DoubleValue::descriptor());
+    descriptors.push_back(google::protobuf::FieldMask::descriptor());
+    descriptors.push_back(google::protobuf::Int32Value::descriptor());
+    descriptors.push_back(google::protobuf::Struct::descriptor());
     descriptors.push_back(google::protobuf::Timestamp::descriptor());
-    descriptors.push_back(google::protobuf::Any::descriptor());
     descriptors.push_back(google::protobuf::Value::descriptor());
-    descriptors.push_back(google::protobuf::Struct::descriptor());
     ResetTypeInfo(descriptors);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterAnyTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyRenderSuccess) {
@@ skipping 12 matching lines @@
       ->EndObject();
   CheckOutput(any);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, RecursiveAny) {
   AnyOut out;
   ::google::protobuf::Any* any = out.mutable_any();
   any->set_type_url("type.googleapis.com/google.protobuf.Any");
 
   ::google::protobuf::Any nested_any;
-  nested_any.set_type_url(
-      "type.googleapis.com/google.protobuf.testing.anys.AnyM");
+  nested_any.set_type_url("type.googleapis.com/google.protobuf.testing.AnyM");
 
   AnyM m;
   m.set_foo("foovalue");
   nested_any.set_value(m.SerializeAsString());
 
   any->set_value(nested_any.SerializeAsString());
 
   ow_->StartObject("")
       ->StartObject("any")
       ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
       ->StartObject("value")
       ->RenderString("@type",
-                     "type.googleapis.com/google.protobuf.testing.anys.AnyM")
+                     "type.googleapis.com/google.protobuf.testing.AnyM")
       ->RenderString("foo", "foovalue")
       ->EndObject()
       ->EndObject()
       ->EndObject();
+  CheckOutput(out, 107);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, DoubleRecursiveAny) {
   AnyOut out;
   ::google::protobuf::Any* any = out.mutable_any();
   any->set_type_url("type.googleapis.com/google.protobuf.Any");
 
   ::google::protobuf::Any nested_any;
   nested_any.set_type_url("type.googleapis.com/google.protobuf.Any");
 
   ::google::protobuf::Any second_nested_any;
   second_nested_any.set_type_url(
-      "type.googleapis.com/google.protobuf.testing.anys.AnyM");
+      "type.googleapis.com/google.protobuf.testing.AnyM");
 
   AnyM m;
   m.set_foo("foovalue");
   second_nested_any.set_value(m.SerializeAsString());
 
   nested_any.set_value(second_nested_any.SerializeAsString());
   any->set_value(nested_any.SerializeAsString());
 
   ow_->StartObject("")
       ->StartObject("any")
       ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
       ->StartObject("value")
       ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
       ->StartObject("value")
       ->RenderString("@type",
-                     "type.googleapis.com/google.protobuf.testing.anys.AnyM")
+                     "type.googleapis.com/google.protobuf.testing.AnyM")
       ->RenderString("foo", "foovalue")
       ->EndObject()
       ->EndObject()
       ->EndObject()
       ->EndObject();
+  CheckOutput(out, 151);
+}
+
+TEST_P(ProtoStreamObjectWriterAnyTest, TypeUrlAtEnd) {
+  Book book;
+  book.set_title("C++");
+  book.set_length(1234);
+  book.set_content("Hello World!");
+
+  ::google::protobuf::Any any;
+  any.PackFrom(book);
+
+  ::google::protobuf::Any outer_any;
+  outer_any.PackFrom(any);
+
+  AnyOut out;
+  out.mutable_any()->PackFrom(outer_any);
+
+  // Put the @type field at the end of each Any message. Parsers should
+  // be able to accept that.
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->StartObject("value")
+      ->StartObject("value")
+      ->RenderString("title", "C++")
+      ->RenderInt32("length", 1234)
+      ->RenderBytes("content", "Hello World!")
+      ->RenderString("@type",
+                     "type.googleapis.com/google.protobuf.testing.Book")
+      ->EndObject()
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
+      ->EndObject()
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
+// Same as TypeUrlAtEnd, but use temporary string values to make sure we don't
+// mistakenly store StringPiece objects pointing to invalid memory.
+TEST_P(ProtoStreamObjectWriterAnyTest, TypeUrlAtEndWithTemporaryStrings) {
+  Book book;
+  book.set_title("C++");
+  book.set_length(1234);
+  book.set_content("Hello World!");
+
+  ::google::protobuf::Any any;
+  any.PackFrom(book);
+
+  ::google::protobuf::Any outer_any;
+  outer_any.PackFrom(any);
+
+  AnyOut out;
+  out.mutable_any()->PackFrom(outer_any);
+
+  string name, value;
+  // Put the @type field at the end of each Any message. Parsers should
+  // be able to accept that.
+  ow_->StartObject("")->StartObject("any");
+  {
+    ow_->StartObject("value");
+    {
+      ow_->StartObject("value");
+      {
+        name = "title";
+        value = "C++";
+        ow_->RenderString(name, value);
+        name = "length";
+        ow_->RenderInt32(name, 1234);
+        name = "content";
+        value = "Hello World!";
+        ow_->RenderBytes(name, value);
+        name = "@type";
+        value = "type.googleapis.com/google.protobuf.testing.Book";
+        ow_->RenderString(name, value);
+      }
+      ow_->EndObject();
+
+      name = "@type";
+      value = "type.googleapis.com/google.protobuf.Any";
+      ow_->RenderString(name, value);
+    }
+    ow_->EndObject();
+
+    name = "@type";
+    value = "type.googleapis.com/google.protobuf.Any";
+    ow_->RenderString(name, value);
+  }
+  ow_->EndObject()->EndObject();
+  CheckOutput(out);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, EmptyAnyFromEmptyObject) {
   AnyOut out;
   out.mutable_any();
 
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+
   ow_->StartObject("")->StartObject("any")->EndObject()->EndObject();
 
   CheckOutput(out, 2);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyWithoutTypeUrlFails1) {
   AnyOut any;
 
-  EXPECT_CALL(
-      listener_,
-      InvalidValue(_, StringPiece("Any"),
-                   StringPiece("Missing or invalid @type for any field in "
-                               "google.protobuf.testing.anys.AnyOut")));
+  EXPECT_CALL(listener_,
+              InvalidValue(_, StringPiece("Any"),
+                           StringPiece("Missing @type for any field in "
+                                       "google.protobuf.testing.AnyOut")));
 
   ow_->StartObject("")
       ->StartObject("any")
       ->StartObject("another")
       ->EndObject()
       ->EndObject()
       ->EndObject();
   CheckOutput(any);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyWithoutTypeUrlFails2) {
   AnyOut any;
 
-  EXPECT_CALL(
-      listener_,
-      InvalidValue(_, StringPiece("Any"),
-                   StringPiece("Missing or invalid @type for any field in "
-                               "google.protobuf.testing.anys.AnyOut")));
+  EXPECT_CALL(listener_,
+              InvalidValue(_, StringPiece("Any"),
+                           StringPiece("Missing @type for any field in "
+                                       "google.protobuf.testing.AnyOut")));
 
   ow_->StartObject("")
       ->StartObject("any")
       ->StartList("another")
       ->EndObject()
       ->EndObject()
       ->EndObject();
   CheckOutput(any);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyWithoutTypeUrlFails3) {
   AnyOut any;
 
-  EXPECT_CALL(
-      listener_,
-      InvalidValue(_, StringPiece("Any"),
-                   StringPiece("Missing or invalid @type for any field in "
-                               "google.protobuf.testing.anys.AnyOut")));
+  EXPECT_CALL(listener_,
+              InvalidValue(_, StringPiece("Any"),
+                           StringPiece("Missing @type for any field in "
+                                       "google.protobuf.testing.AnyOut")));
 
   ow_->StartObject("")
       ->StartObject("any")
       ->RenderString("value", "somevalue")
       ->EndObject()
       ->EndObject();
   CheckOutput(any);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyWithInvalidTypeUrlFails) {
@@ skipping 24 matching lines @@
                    StringPiece("Invalid type URL, unknown type: some.Type")));
   ow_->StartObject("")
       ->StartObject("any")
       ->RenderString("@type", "type.googleapis.com/some.Type")
       ->RenderDouble("value", 40.2)
       ->EndObject()
       ->EndObject();
   CheckOutput(any);
 }
 
-TEST_P(ProtoStreamObjectWriterAnyTest, AnyNullInputFails) {
+TEST_P(ProtoStreamObjectWriterAnyTest, AnyIncorrectInputTypeFails) {
   AnyOut any;
 
+  EXPECT_CALL(
+      listener_,
+      InvalidValue(_, StringPiece("type.googleapis.com/google.protobuf.Any"),
+                   StringPiece("1")));
+  ow_->StartObject("")->RenderInt32("any", 1)->EndObject();
+  CheckOutput(any);
+}
+
+TEST_P(ProtoStreamObjectWriterAnyTest, AnyAcceptsNull) {
+  AnyOut any;
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
   ow_->StartObject("")->RenderNull("any")->EndObject();
   CheckOutput(any);
 }
 
 TEST_P(ProtoStreamObjectWriterAnyTest, AnyWellKnownTypeErrorTest) {
   EXPECT_CALL(listener_, InvalidValue(_, StringPiece("Any"),
                                       StringPiece("Invalid time format: ")));
 
   AnyOut any;
   google::protobuf::Any* any_type = any.mutable_any();
@@ skipping 217 matching lines @@
 
   ow_->StartObject("")
       ->StartObject("any")
       ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
       ->RenderString("value", "")
       ->EndObject()
       ->EndObject();
   CheckOutput(any);
 }
 
+// {
+//   "any": {
+//     "@type": "type.googleapis.com/google.protobuf.Any",
+//     "value": null
+//   }
+// }
+TEST_P(ProtoStreamObjectWriterAnyTest, AnyInAnyAcceptsNull) {
+  AnyOut out;
+  google::protobuf::Any empty;
+  out.mutable_any()->PackFrom(empty);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Any")
+      ->RenderNull("value")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
+// {
+//   "any": {
+//     "@type": "type.googleapis.com/google.protobuf.Timestamp",
+//     "value": null
+//   }
+// }
+TEST_P(ProtoStreamObjectWriterAnyTest, TimestampInAnyAcceptsNull) {
+  AnyOut out;
+  google::protobuf::Timestamp empty;
+  out.mutable_any()->PackFrom(empty);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Timestamp")
+      ->RenderNull("value")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
+// {
+//   "any": {
+//     "@type": "type.googleapis.com/google.protobuf.Duration",
+//     "value": null
+//   }
+// }
+TEST_P(ProtoStreamObjectWriterAnyTest, DurationInAnyAcceptsNull) {
+  AnyOut out;
+  google::protobuf::Duration empty;
+  out.mutable_any()->PackFrom(empty);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Duration")
+      ->RenderNull("value")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
+// {
+//   "any": {
+//     "@type": "type.googleapis.com/google.protobuf.FieldMask",
+//     "value": null
+//   }
+// }
+TEST_P(ProtoStreamObjectWriterAnyTest, FieldMaskInAnyAcceptsNull) {
+  AnyOut out;
+  google::protobuf::FieldMask empty;
+  out.mutable_any()->PackFrom(empty);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.FieldMask")
+      ->RenderNull("value")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
+// {
+//   "any": {
+//     "@type": "type.googleapis.com/google.protobuf.Int32Value",
+//     "value": null
+//   }
+// }
+TEST_P(ProtoStreamObjectWriterAnyTest, WrapperInAnyAcceptsNull) {
+  AnyOut out;
+  google::protobuf::Int32Value empty;
+  out.mutable_any()->PackFrom(empty);
+
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")
+      ->StartObject("any")
+      ->RenderString("@type", "type.googleapis.com/google.protobuf.Int32Value")
+      ->RenderNull("value")
+      ->EndObject()
+      ->EndObject();
+  CheckOutput(out);
+}
+
 class ProtoStreamObjectWriterFieldMaskTest
     : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterFieldMaskTest() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(FieldMaskTest::descriptor());
     descriptors.push_back(google::protobuf::FieldMask::descriptor());
     ResetTypeInfo(descriptors);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterFieldMaskTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
@@ skipping 220 matching lines @@
   ow_->StartObject("");
   ow_->RenderString(
       "single_mask",
       "path.to.map[\"(),[],\\\"'!@#$%^&*123_|War\xE5\xAD\x99,./?><\\\\\"],"
       "path.to.map[\"key2\"]");
   ow_->EndObject();
 
   CheckOutput(expected);
 }
 
+TEST_P(ProtoStreamObjectWriterFieldMaskTest, FieldMaskAcceptsNull) {
+  FieldMaskTest expected;
+  EXPECT_CALL(listener_, InvalidValue(_, _, _)).Times(0);
+  ow_->StartObject("")->RenderNull("single_mask")->EndObject();
+  CheckOutput(expected);
+}
+
+class ProtoStreamObjectWriterWrappersTest
+    : public BaseProtoStreamObjectWriterTest {
+ protected:
+  ProtoStreamObjectWriterWrappersTest() {
+    std::vector<const Descriptor*> descriptors;
+    descriptors.push_back(Int32Wrapper::descriptor());
+    descriptors.push_back(google::protobuf::Int32Value::descriptor());
+    ResetTypeInfo(descriptors);
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
+                        ProtoStreamObjectWriterWrappersTest,
+                        ::testing::Values(
+                            testing::USE_TYPE_RESOLVER));
+
+TEST_P(ProtoStreamObjectWriterWrappersTest, WrapperAcceptsNull) {
+  Int32Wrapper wrapper;
+  EXPECT_CALL(listener_, InvalidName(_, _, _)).Times(0);
+  ow_->StartObject("")->RenderNull("int32")->EndObject();
+  CheckOutput(wrapper);
+}
+
 class ProtoStreamObjectWriterOneOfsTest
     : public BaseProtoStreamObjectWriterTest {
  protected:
   ProtoStreamObjectWriterOneOfsTest() {
-    vector<const Descriptor*> descriptors;
+    std::vector<const Descriptor*> descriptors;
     descriptors.push_back(OneOfsRequest::descriptor());
     descriptors.push_back(google::protobuf::Struct::descriptor());
     ResetTypeInfo(descriptors);
   }
 };
 
 INSTANTIATE_TEST_CASE_P(DifferentTypeInfoSourceTest,
                         ProtoStreamObjectWriterOneOfsTest,
                         ::testing::Values(
                             testing::USE_TYPE_RESOLVER));
@@ skipping 142 matching lines @@
   ow_->EndObject();
 }
 
 TEST_P(ProtoStreamObjectWriterOneOfsTest,
        MultipleOneofsFailForOneofWithinAnyTest) {
   EXPECT_CALL(listener_,
               InvalidValue(_, StringPiece("oneof"),
                            StringPiece("oneof field 'data' is already set. "
                                        "Cannot set 'intData'")));
 
-  using google::protobuf::testing::oneofs::OneOfsRequest;
   // JSON:
   // { "anyData":
   //    { "@type":
   //       "type.googleapis.com/google.protobuf.testing.oneofs.OneOfsRequest",
   //     "strData": "blah",
   //     "intData": 123
   //    }
   // }
   ow_->StartObject("");
   ow_->StartObject("anyData");
   ow_->RenderString(
       "@type",
       "type.googleapis.com/google.protobuf.testing.oneofs.OneOfsRequest");
   ow_->RenderString("strData", "blah");
   ow_->RenderInt32("intData", 123);
   ow_->EndObject();
   ow_->EndObject();
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google