third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/python/google/protobuf/internal/message_test.py

 #! /usr/bin/env python
 #
 # 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:
 #
@@ skipping 49 matching lines @@
 from google.protobuf import map_unittest_pb2
 from google.protobuf import unittest_pb2
 from google.protobuf import unittest_proto3_arena_pb2
 from google.protobuf import descriptor_pb2
 from google.protobuf import descriptor_pool
 from google.protobuf import message_factory
 from google.protobuf import text_format
 from google.protobuf.internal import api_implementation
 from google.protobuf.internal import packed_field_test_pb2
 from google.protobuf.internal import test_util
+from google.protobuf.internal import testing_refleaks
 from google.protobuf import message
 from google.protobuf.internal import _parameterized
 
 if six.PY3:
   long = int
 
 
 # Python pre-2.6 does not have isinf() or isnan() functions, so we have
 # to provide our own.
 def isnan(val):
   # NaN is never equal to itself.
   return val != val
 def isinf(val):
   # Infinity times zero equals NaN.
   return not isnan(val) and isnan(val * 0)
 def IsPosInf(val):
   return isinf(val) and (val > 0)
 def IsNegInf(val):
   return isinf(val) and (val < 0)
 
 
-@_parameterized.Parameters(
-    (unittest_pb2),
-    (unittest_proto3_arena_pb2))
-class MessageTest(unittest.TestCase):
+BaseTestCase = testing_refleaks.BaseTestCase
+
+
+@_parameterized.NamedParameters(
+    ('_proto2', unittest_pb2),
+    ('_proto3', unittest_proto3_arena_pb2))
+class MessageTest(BaseTestCase):
 
   def testBadUtf8String(self, message_module):
     if api_implementation.Type() != 'python':
       self.skipTest("Skipping testBadUtf8String, currently only the python "
                     "api implementation raises UnicodeDecodeError when a "
                     "string field contains bad utf-8.")
     bad_utf8_data = test_util.GoldenFileData('bad_utf8_string')
     with self.assertRaises(UnicodeDecodeError) as context:
       message_module.TestAllTypes.FromString(bad_utf8_data)
     self.assertIn('TestAllTypes.optional_string', str(context.exception))
@@ skipping 845 matching lines @@
     for i in range(5):
       n = m.repeated_nested_message.add()
       n.bb = i
     self.assertEqual(4, m.repeated_nested_message.pop().bb)
     self.assertEqual(0, m.repeated_nested_message.pop(0).bb)
     self.assertEqual(2, m.repeated_nested_message.pop(1).bb)
     self.assertEqual([1, 3], [n.bb for n in m.repeated_nested_message])
 
 
 # Class to test proto2-only features (required, extensions, etc.)
-class Proto2Test(unittest.TestCase):
+class Proto2Test(BaseTestCase):
 
   def testFieldPresence(self):
     message = unittest_pb2.TestAllTypes()
 
     self.assertFalse(message.HasField("optional_int32"))
     self.assertFalse(message.HasField("optional_bool"))
     self.assertFalse(message.HasField("optional_nested_message"))
 
     with self.assertRaises(ValueError):
       message.HasField("field_doesnt_exist")
@@ skipping 135 matching lines @@
         unittest_pb2.TestParsingMerge.repeated_ext]), 3)
 
   def testPythonicInit(self):
     message = unittest_pb2.TestAllTypes(
         optional_int32=100,
         optional_fixed32=200,
         optional_float=300.5,
         optional_bytes=b'x',
         optionalgroup={'a': 400},
         optional_nested_message={'bb': 500},
+        optional_foreign_message={},
         optional_nested_enum='BAZ',
         repeatedgroup=[{'a': 600},
                        {'a': 700}],
         repeated_nested_enum=['FOO', unittest_pb2.TestAllTypes.BAR],
         default_int32=800,
         oneof_string='y')
     self.assertIsInstance(message, unittest_pb2.TestAllTypes)
     self.assertEqual(100, message.optional_int32)
     self.assertEqual(200, message.optional_fixed32)
     self.assertEqual(300.5, message.optional_float)
     self.assertEqual(b'x', message.optional_bytes)
     self.assertEqual(400, message.optionalgroup.a)
-    self.assertIsInstance(message.optional_nested_message, unittest_pb2.TestAllTypes.NestedMessage)
+    self.assertIsInstance(message.optional_nested_message,
+                          unittest_pb2.TestAllTypes.NestedMessage)
     self.assertEqual(500, message.optional_nested_message.bb)
+    self.assertTrue(message.HasField('optional_foreign_message'))
+    self.assertEqual(message.optional_foreign_message,
+                     unittest_pb2.ForeignMessage())
     self.assertEqual(unittest_pb2.TestAllTypes.BAZ,
                      message.optional_nested_enum)
     self.assertEqual(2, len(message.repeatedgroup))
     self.assertEqual(600, message.repeatedgroup[0].a)
     self.assertEqual(700, message.repeatedgroup[1].a)
     self.assertEqual(2, len(message.repeated_nested_enum))
     self.assertEqual(unittest_pb2.TestAllTypes.FOO,
                      message.repeated_nested_enum[0])
     self.assertEqual(unittest_pb2.TestAllTypes.BAR,
                      message.repeated_nested_enum[1])
@@ skipping 17 matching lines @@
 
     with self.assertRaises(ValueError):
       unittest_pb2.TestAllTypes(optional_nested_enum='INVALID_LABEL')
 
     with self.assertRaises(ValueError):
       unittest_pb2.TestAllTypes(repeated_nested_enum='FOO')
 
 
 
 # Class to test proto3-only features/behavior (updated field presence & enums)
-class Proto3Test(unittest.TestCase):
+class Proto3Test(BaseTestCase):
 
   # Utility method for comparing equality with a map.
   def assertMapIterEquals(self, map_iter, dict_value):
     # Avoid mutating caller's copy.
     dict_value = dict(dict_value)
 
     for k, v in map_iter:
       self.assertEqual(v, dict_value[k])
       del dict_value[k]
 
@@ skipping 250 matching lines @@
     msg.map_int32_int32[12] = 34
     msg.map_int32_int32[56] = 78
     msg.map_int64_int64[22] = 33
     msg.map_int32_foreign_message[111].c = 5
     msg.map_int32_foreign_message[222].c = 10
 
     msg2 = map_unittest_pb2.TestMap()
     msg2.map_int32_int32[12] = 55
     msg2.map_int64_int64[88] = 99
     msg2.map_int32_foreign_message[222].c = 15
+    msg2.map_int32_foreign_message[222].d = 20
+    old_map_value = msg2.map_int32_foreign_message[222]
 
     msg2.MergeFrom(msg)
 
     self.assertEqual(34, msg2.map_int32_int32[12])
     self.assertEqual(78, msg2.map_int32_int32[56])
     self.assertEqual(33, msg2.map_int64_int64[22])
     self.assertEqual(99, msg2.map_int64_int64[88])
     self.assertEqual(5, msg2.map_int32_foreign_message[111].c)
     self.assertEqual(10, msg2.map_int32_foreign_message[222].c)
+    self.assertFalse(msg2.map_int32_foreign_message[222].HasField('d'))
+    self.assertEqual(15, old_map_value.c)
 
     # Verify that there is only one entry per key, even though the MergeFrom
     # may have internally created multiple entries for a single key in the
     # list representation.
     as_dict = {}
     for key in msg2.map_int32_foreign_message:
       self.assertFalse(key in as_dict)
       as_dict[key] = msg2.map_int32_foreign_message[key].c
 
     self.assertEqual({111: 5, 222: 10}, as_dict)
@@ skipping 252 matching lines @@
 
   def testMapFindInitializationErrorsSmokeTest(self):
     msg = map_unittest_pb2.TestMap()
     msg.map_string_string['abc'] = '123'
     msg.map_int32_int32[35] = 64
     msg.map_string_foreign_message['foo'].c = 5
     self.assertEqual(0, len(msg.FindInitializationErrors()))
 
 
 
-class ValidTypeNamesTest(unittest.TestCase):
+class ValidTypeNamesTest(BaseTestCase):
 
   def assertImportFromName(self, msg, base_name):
     # Parse <type 'module.class_name'> to extra 'some.name' as a string.
     tp_name = str(type(msg)).split("'")[1]
     valid_names = ('Repeated%sContainer' % base_name,
                    'Repeated%sFieldContainer' % base_name)
     self.assertTrue(any(tp_name.endswith(v) for v in valid_names),
                     '%r does end with any of %r' % (tp_name, valid_names))
 
     parts = tp_name.split('.')
     class_name = parts[-1]
     module_name = '.'.join(parts[:-1])
     __import__(module_name, fromlist=[class_name])
 
   def testTypeNamesCanBeImported(self):
     # If import doesn't work, pickling won't work either.
     pb = unittest_pb2.TestAllTypes()
     self.assertImportFromName(pb.repeated_int32, 'Scalar')
     self.assertImportFromName(pb.repeated_nested_message, 'Composite')
 
-class PackedFieldTest(unittest.TestCase):
+class PackedFieldTest(BaseTestCase):
 
   def setMessage(self, message):
     message.repeated_int32.append(1)
     message.repeated_int64.append(1)
     message.repeated_uint32.append(1)
     message.repeated_uint64.append(1)
     message.repeated_sint32.append(1)
     message.repeated_sint64.append(1)
     message.repeated_fixed32.append(1)
     message.repeated_fixed64.append(1)
@@ skipping 38 matching lines @@
                    b'\x51\x01\x00\x00\x00\x00\x00\x00\x00'
                    b'\x5D\x00\x00\x80\x3f'
                    b'\x61\x00\x00\x00\x00\x00\x00\xf0\x3f'
                    b'\x68\x01'
                    b'\x70\x01')
     self.assertEqual(golden_data, message.SerializeToString())
 
 
 @unittest.skipIf(api_implementation.Type() != 'cpp',
                  'explicit tests of the C++ implementation')
-class OversizeProtosTest(unittest.TestCase):
+class OversizeProtosTest(BaseTestCase):
 
-  def setUp(self):
-    self.file_desc = """
+  @classmethod
+  def setUpClass(cls):
+    # At the moment, reference cycles between DescriptorPool and Message classes
+    # are not detected and these objects are never freed.
+    # To avoid errors with ReferenceLeakChecker, we create the class only once.
+    file_desc = """
       name: "f/f.msg2"
       package: "f"
       message_type {
         name: "msg1"
         field {
           name: "payload"
           number: 1
           label: LABEL_OPTIONAL
           type: TYPE_STRING
         }
       }
       message_type {
         name: "msg2"
         field {
           name: "field"
           number: 1
           label: LABEL_OPTIONAL
           type: TYPE_MESSAGE
           type_name: "msg1"
         }
       }
     """
     pool = descriptor_pool.DescriptorPool()
     desc = descriptor_pb2.FileDescriptorProto()
-    text_format.Parse(self.file_desc, desc)
+    text_format.Parse(file_desc, desc)
     pool.Add(desc)
-    self.proto_cls = message_factory.MessageFactory(pool).GetPrototype(
+    cls.proto_cls = message_factory.MessageFactory(pool).GetPrototype(
         pool.FindMessageTypeByName('f.msg2'))
+
+  def setUp(self):
     self.p = self.proto_cls()
     self.p.field.payload = 'c' * (1024 * 1024 * 64 + 1)
     self.p_serialized = self.p.SerializeToString()
 
   def testAssertOversizeProto(self):
     from google.protobuf.pyext._message import SetAllowOversizeProtos
     SetAllowOversizeProtos(False)
     q = self.proto_cls()
     try:
       q.ParseFromString(self.p_serialized)
     except message.DecodeError as e:
       self.assertEqual(str(e), 'Error parsing message')
 
   def testSucceedOversizeProto(self):
     from google.protobuf.pyext._message import SetAllowOversizeProtos
     SetAllowOversizeProtos(True)
     q = self.proto_cls()
     q.ParseFromString(self.p_serialized)
     self.assertEqual(self.p.field.payload, q.field.payload)
 
 if __name__ == '__main__':
   unittest.main()