third_party/protobuf: Update to HEAD (f52e188fe4)

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

 #! /usr/bin/env python
 # -*- coding: utf-8 -*-
 #
 # 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 42 matching lines @@
 from google.protobuf import descriptor
 from google.protobuf import message
 from google.protobuf import reflection
 from google.protobuf import text_format
 from google.protobuf.internal import api_implementation
 from google.protobuf.internal import more_extensions_pb2
 from google.protobuf.internal import more_messages_pb2
 from google.protobuf.internal import message_set_extensions_pb2
 from google.protobuf.internal import wire_format
 from google.protobuf.internal import test_util
+from google.protobuf.internal import testing_refleaks
 from google.protobuf.internal import decoder
 
 
+BaseTestCase = testing_refleaks.BaseTestCase
+
+
 class _MiniDecoder(object):
   """Decodes a stream of values from a string.
 
   Once upon a time we actually had a class called decoder.Decoder.  Then we
   got rid of it during a redesign that made decoding much, much faster overall.
   But a couple tests in this file used it to check that the serialized form of
   a message was correct.  So, this class implements just the methods that were
   used by said tests, so that we don't have to rewrite the tests.
   """
 
@@ skipping 12 matching lines @@
 
   def ReadSInt64(self):
     return wire_format.ZigZagDecode(self.ReadVarint())
 
   ReadSInt32 = ReadSInt64
 
   def ReadFieldNumberAndWireType(self):
     return wire_format.UnpackTag(self.ReadVarint())
 
   def ReadFloat(self):
-    result = struct.unpack("<f", self._bytes[self._pos:self._pos+4])[0]
+    result = struct.unpack('<f', self._bytes[self._pos:self._pos+4])[0]
     self._pos += 4
     return result
 
   def ReadDouble(self):
-    result = struct.unpack("<d", self._bytes[self._pos:self._pos+8])[0]
+    result = struct.unpack('<d', self._bytes[self._pos:self._pos+8])[0]
     self._pos += 8
     return result
 
   def EndOfStream(self):
     return self._pos == len(self._bytes)
 
 
-class ReflectionTest(unittest.TestCase):
+class ReflectionTest(BaseTestCase):
 
   def assertListsEqual(self, values, others):
     self.assertEqual(len(values), len(others))
     for i in range(len(values)):
       self.assertEqual(values[i], others[i])
 
   def testScalarConstructor(self):
     # Constructor with only scalar types should succeed.
     proto = unittest_pb2.TestAllTypes(
         optional_int32=24,
@@ skipping 488 matching lines @@
     # proto.nonexistent_field = 23 should fail as well.
     self.assertRaises(AttributeError, setattr, proto, 'nonexistent_field', 23)
 
   def testSingleScalarTypeSafety(self):
     proto = unittest_pb2.TestAllTypes()
     self.assertRaises(TypeError, setattr, proto, 'optional_int32', 1.1)
     self.assertRaises(TypeError, setattr, proto, 'optional_int32', 'foo')
     self.assertRaises(TypeError, setattr, proto, 'optional_string', 10)
     self.assertRaises(TypeError, setattr, proto, 'optional_bytes', 10)
 
-  def testIntegerTypes(self):
+  def assertIntegerTypes(self, integer_fn):
+    """Verifies setting of scalar integers.
+
+    Args:
+      integer_fn: A function to wrap the integers that will be assigned.
+    """
     def TestGetAndDeserialize(field_name, value, expected_type):
       proto = unittest_pb2.TestAllTypes()
+      value = integer_fn(value)
       setattr(proto, field_name, value)
       self.assertIsInstance(getattr(proto, field_name), expected_type)
       proto2 = unittest_pb2.TestAllTypes()
       proto2.ParseFromString(proto.SerializeToString())
       self.assertIsInstance(getattr(proto2, field_name), expected_type)
 
     TestGetAndDeserialize('optional_int32', 1, int)
     TestGetAndDeserialize('optional_int32', 1 << 30, int)
     TestGetAndDeserialize('optional_uint32', 1 << 30, int)
     try:
       integer_64 = long
-    except NameError: # Python3
+    except NameError:  # Python3
       integer_64 = int
     if struct.calcsize('L') == 4:
       # Python only has signed ints, so 32-bit python can't fit an uint32
       # in an int.
-      TestGetAndDeserialize('optional_uint32', 1 << 31, long)
+      TestGetAndDeserialize('optional_uint32', 1 << 31, integer_64)
     else:
       # 64-bit python can fit uint32 inside an int
       TestGetAndDeserialize('optional_uint32', 1 << 31, int)
     TestGetAndDeserialize('optional_int64', 1 << 30, integer_64)
     TestGetAndDeserialize('optional_int64', 1 << 60, integer_64)
     TestGetAndDeserialize('optional_uint64', 1 << 30, integer_64)
     TestGetAndDeserialize('optional_uint64', 1 << 60, integer_64)
 
-  def testSingleScalarBoundsChecking(self):
+  def testIntegerTypes(self):
+    self.assertIntegerTypes(lambda x: x)
+
+  def testNonStandardIntegerTypes(self):
+    self.assertIntegerTypes(test_util.NonStandardInteger)
+
+  def testIllegalValuesForIntegers(self):
+    pb = unittest_pb2.TestAllTypes()
+
+    # Strings are illegal, even when the represent an integer.
+    with self.assertRaises(TypeError):
+      pb.optional_uint64 = '2'
+
+    # The exact error should propagate with a poorly written custom integer.
+    with self.assertRaisesRegexp(RuntimeError, 'my_error'):
+      pb.optional_uint64 = test_util.NonStandardInteger(5, 'my_error')
+
+  def assetIntegerBoundsChecking(self, integer_fn):
+    """Verifies bounds checking for scalar integer fields.
+
+    Args:
+      integer_fn: A function to wrap the integers that will be assigned.
+    """
     def TestMinAndMaxIntegers(field_name, expected_min, expected_max):
       pb = unittest_pb2.TestAllTypes()
+      expected_min = integer_fn(expected_min)
+      expected_max = integer_fn(expected_max)
       setattr(pb, field_name, expected_min)
       self.assertEqual(expected_min, getattr(pb, field_name))
       setattr(pb, field_name, expected_max)
       self.assertEqual(expected_max, getattr(pb, field_name))
       self.assertRaises(ValueError, setattr, pb, field_name, expected_min - 1)
       self.assertRaises(ValueError, setattr, pb, field_name, expected_max + 1)
 
     TestMinAndMaxIntegers('optional_int32', -(1 << 31), (1 << 31) - 1)
     TestMinAndMaxIntegers('optional_uint32', 0, 0xffffffff)
     TestMinAndMaxIntegers('optional_int64', -(1 << 63), (1 << 63) - 1)
     TestMinAndMaxIntegers('optional_uint64', 0, 0xffffffffffffffff)
+    # A bit of white-box testing since -1 is an int and not a long in C++ and
+    # so goes down a different path.
+    pb = unittest_pb2.TestAllTypes()
+    with self.assertRaises(ValueError):
+      pb.optional_uint64 = integer_fn(-(1 << 63))
 
     pb = unittest_pb2.TestAllTypes()
-    pb.optional_nested_enum = 1
+    pb.optional_nested_enum = integer_fn(1)
     self.assertEqual(1, pb.optional_nested_enum)
 
+  def testSingleScalarBoundsChecking(self):
+    self.assetIntegerBoundsChecking(lambda x: x)
+
+  def testNonStandardSingleScalarBoundsChecking(self):
+    self.assetIntegerBoundsChecking(test_util.NonStandardInteger)
+
   def testRepeatedScalarTypeSafety(self):
     proto = unittest_pb2.TestAllTypes()
     self.assertRaises(TypeError, proto.repeated_int32.append, 1.1)
     self.assertRaises(TypeError, proto.repeated_int32.append, 'foo')
     self.assertRaises(TypeError, proto.repeated_string, 10)
     self.assertRaises(TypeError, proto.repeated_bytes, 10)
 
     proto.repeated_int32.append(10)
     proto.repeated_int32[0] = 23
     self.assertRaises(IndexError, proto.repeated_int32.__setitem__, 500, 23)
@@ skipping 288 matching lines @@
 
     # Test clearing.
     proto.ClearField('repeated_nested_message')
     self.assertTrue(not proto.repeated_nested_message)
     self.assertEqual(0, len(proto.repeated_nested_message))
 
     # Test constructing an element while adding it.
     proto.repeated_nested_message.add(bb=23)
     self.assertEqual(1, len(proto.repeated_nested_message))
     self.assertEqual(23, proto.repeated_nested_message[0].bb)
+    self.assertRaises(TypeError, proto.repeated_nested_message.add, 23)
 
   def testRepeatedCompositeRemove(self):
     proto = unittest_pb2.TestAllTypes()
 
     self.assertEqual(0, len(proto.repeated_nested_message))
     m0 = proto.repeated_nested_message.add()
     # Need to set some differentiating variable so m0 != m1 != m2:
     m0.bb = len(proto.repeated_nested_message)
     m1 = proto.repeated_nested_message.add()
     m1.bb = len(proto.repeated_nested_message)
@@ skipping 190 matching lines @@
     self.assertEqual(0, required.a)
     self.assertTrue(not extendee_proto.HasExtension(extension))
     required.a = 23
     self.assertEqual(23, extendee_proto.Extensions[extension].a)
     self.assertTrue(extendee_proto.HasExtension(extension))
     extendee_proto.ClearExtension(extension)
     self.assertTrue(required is not extendee_proto.Extensions[extension])
     self.assertTrue(not extendee_proto.HasExtension(extension))
 
   def testRegisteredExtensions(self):
-    self.assertTrue('protobuf_unittest.optional_int32_extension' in
-                    unittest_pb2.TestAllExtensions._extensions_by_name)
-    self.assertTrue(1 in unittest_pb2.TestAllExtensions._extensions_by_number)
+    pool = unittest_pb2.DESCRIPTOR.pool
+    self.assertTrue(
+        pool.FindExtensionByNumber(
+            unittest_pb2.TestAllExtensions.DESCRIPTOR, 1))
+    self.assertIs(
+        pool.FindExtensionByName(
+            'protobuf_unittest.optional_int32_extension').containing_type,
+        unittest_pb2.TestAllExtensions.DESCRIPTOR)
     # Make sure extensions haven't been registered into types that shouldn't
     # have any.
-    self.assertEqual(0, len(unittest_pb2.TestAllTypes._extensions_by_name))
+    self.assertEqual(0, len(
+        pool.FindAllExtensions(unittest_pb2.TestAllTypes.DESCRIPTOR)))
 
   # If message A directly contains message B, and
   # a.HasField('b') is currently False, then mutating any
   # extension in B should change a.HasField('b') to True
   # (and so on up the object tree).
   def testHasBitsForAncestorsOfExtendedMessage(self):
     # Optional scalar extension.
     toplevel = more_extensions_pb2.TopLevelMessage()
     self.assertTrue(not toplevel.HasField('submessage'))
     self.assertEqual(0, toplevel.submessage.Extensions[
@@ skipping 343 matching lines @@
     self.assertTrue(foreign is not proto.optional_foreign_message)
     self.assertEqual(5, nested.bb)
     self.assertEqual(6, foreign.c)
     nested.bb = 15
     foreign.c = 16
     self.assertFalse(proto.HasField('optional_nested_message'))
     self.assertEqual(0, proto.optional_nested_message.bb)
     self.assertFalse(proto.HasField('optional_foreign_message'))
     self.assertEqual(0, proto.optional_foreign_message.c)
 
+  def testDisconnectingInOneof(self):
+    m = unittest_pb2.TestOneof2()  # This message has two messages in a oneof.
+    m.foo_message.qux_int = 5
+    sub_message = m.foo_message
+    # Accessing another message's field does not clear the first one
+    self.assertEqual(m.foo_lazy_message.qux_int, 0)
+    self.assertEqual(m.foo_message.qux_int, 5)
+    # But mutating another message in the oneof detaches the first one.
+    m.foo_lazy_message.qux_int = 6
+    self.assertEqual(m.foo_message.qux_int, 0)
+    # The reference we got above was detached and is still valid.
+    self.assertEqual(sub_message.qux_int, 5)
+    sub_message.qux_int = 7
+
   def testOneOf(self):
     proto = unittest_pb2.TestAllTypes()
     proto.oneof_uint32 = 10
     proto.oneof_nested_message.bb = 11
     self.assertEqual(11, proto.oneof_nested_message.bb)
     self.assertFalse(proto.HasField('oneof_uint32'))
     nested = proto.oneof_nested_message
     proto.oneof_string = 'abc'
     self.assertEqual('abc', proto.oneof_string)
     self.assertEqual(11, nested.bb)
@@ skipping 238 matching lines @@
     from google.protobuf.internal import import_test_package
     # pylint: enable=g-import-not-at-top
     msg = import_test_package.myproto.Outer()
     # Just check the default value.
     self.assertEqual(57, msg.inner.value)
 
 #  Since we had so many tests for protocol buffer equality, we broke these out
 #  into separate TestCase classes.
 
 
-class TestAllTypesEqualityTest(unittest.TestCase):
+class TestAllTypesEqualityTest(BaseTestCase):
 
   def setUp(self):
     self.first_proto = unittest_pb2.TestAllTypes()
     self.second_proto = unittest_pb2.TestAllTypes()
 
   def testNotHashable(self):
     self.assertRaises(TypeError, hash, self.first_proto)
 
   def testSelfEquality(self):
     self.assertEqual(self.first_proto, self.first_proto)
 
   def testEmptyProtosEqual(self):
     self.assertEqual(self.first_proto, self.second_proto)
 
 
-class FullProtosEqualityTest(unittest.TestCase):
+class FullProtosEqualityTest(BaseTestCase):
 
   """Equality tests using completely-full protos as a starting point."""
 
   def setUp(self):
     self.first_proto = unittest_pb2.TestAllTypes()
     self.second_proto = unittest_pb2.TestAllTypes()
     test_util.SetAllFields(self.first_proto)
     test_util.SetAllFields(self.second_proto)
 
   def testNotHashable(self):
@@ skipping 65 matching lines @@
     # Ensure that we test "has" bits as well as value for
     # nonrepeated composite field.
     self.first_proto.ClearField('optional_nested_message')
     self.second_proto.optional_nested_message.ClearField('bb')
     self.assertNotEqual(self.first_proto, self.second_proto)
     self.first_proto.optional_nested_message.bb = 0
     self.first_proto.optional_nested_message.ClearField('bb')
     self.assertEqual(self.first_proto, self.second_proto)
 
 
-class ExtensionEqualityTest(unittest.TestCase):
+class ExtensionEqualityTest(BaseTestCase):
 
   def testExtensionEquality(self):
     first_proto = unittest_pb2.TestAllExtensions()
     second_proto = unittest_pb2.TestAllExtensions()
     self.assertEqual(first_proto, second_proto)
     test_util.SetAllExtensions(first_proto)
     self.assertNotEqual(first_proto, second_proto)
     test_util.SetAllExtensions(second_proto)
     self.assertEqual(first_proto, second_proto)
 
@@ skipping 12 matching lines @@
 
     # Ensure that differences in cached values
     # don't matter if "has" bits are both false.
     first_proto = unittest_pb2.TestAllExtensions()
     second_proto = unittest_pb2.TestAllExtensions()
     self.assertEqual(
         0, first_proto.Extensions[unittest_pb2.optional_int32_extension])
     self.assertEqual(first_proto, second_proto)
 
 
-class MutualRecursionEqualityTest(unittest.TestCase):
+class MutualRecursionEqualityTest(BaseTestCase):
 
   def testEqualityWithMutualRecursion(self):
     first_proto = unittest_pb2.TestMutualRecursionA()
     second_proto = unittest_pb2.TestMutualRecursionA()
     self.assertEqual(first_proto, second_proto)
     first_proto.bb.a.bb.optional_int32 = 23
     self.assertNotEqual(first_proto, second_proto)
     second_proto.bb.a.bb.optional_int32 = 23
     self.assertEqual(first_proto, second_proto)
 
 
-class ByteSizeTest(unittest.TestCase):
+class ByteSizeTest(BaseTestCase):
 
   def setUp(self):
     self.proto = unittest_pb2.TestAllTypes()
     self.extended_proto = more_extensions_pb2.ExtendedMessage()
     self.packed_proto = unittest_pb2.TestPackedTypes()
     self.packed_extended_proto = unittest_pb2.TestPackedExtensions()
 
   def Size(self):
     return self.proto.ByteSize()
 
@@ skipping 275 matching lines @@
 #   * Handling of unrecognized tags ("uninterpreted_bytes").
 #   * Handling of MessageSets.
 #   * Consistent ordering of tags in the wire format,
 #     including ordering between extensions and non-extension
 #     fields.
 #   * Consistent serialization of negative numbers, especially
 #     negative int32s.
 #   * Handling of empty submessages (with and without "has"
 #     bits set).
 
-class SerializationTest(unittest.TestCase):
+class SerializationTest(BaseTestCase):
 
   def testSerializeEmtpyMessage(self):
     first_proto = unittest_pb2.TestAllTypes()
     second_proto = unittest_pb2.TestAllTypes()
     serialized = first_proto.SerializeToString()
     self.assertEqual(first_proto.ByteSize(), len(serialized))
     self.assertEqual(
         len(serialized),
         second_proto.MergeFromString(serialized))
     self.assertEqual(first_proto, second_proto)
@@ skipping 540 matching lines @@
     self.assertEqual(1, proto.optional_message.c)
 
   def testInitRepeatedKwargs(self):
     proto = unittest_pb2.TestAllTypes(repeated_int32=[1, 2, 3])
     self.assertTrue(proto.IsInitialized())
     self.assertEqual(1, proto.repeated_int32[0])
     self.assertEqual(2, proto.repeated_int32[1])
     self.assertEqual(3, proto.repeated_int32[2])
 
 
-class OptionsTest(unittest.TestCase):
+class OptionsTest(BaseTestCase):
 
   def testMessageOptions(self):
     proto = message_set_extensions_pb2.TestMessageSet()
     self.assertEqual(True,
                      proto.DESCRIPTOR.GetOptions().message_set_wire_format)
     proto = unittest_pb2.TestAllTypes()
     self.assertEqual(False,
                      proto.DESCRIPTOR.GetOptions().message_set_wire_format)
 
   def testPackedOptions(self):
     proto = unittest_pb2.TestAllTypes()
     proto.optional_int32 = 1
     proto.optional_double = 3.0
     for field_descriptor, _ in proto.ListFields():
       self.assertEqual(False, field_descriptor.GetOptions().packed)
 
     proto = unittest_pb2.TestPackedTypes()
     proto.packed_int32.append(1)
     proto.packed_double.append(3.0)
     for field_descriptor, _ in proto.ListFields():
       self.assertEqual(True, field_descriptor.GetOptions().packed)
       self.assertEqual(descriptor.FieldDescriptor.LABEL_REPEATED,
                        field_descriptor.label)
 
 
 
-class ClassAPITest(unittest.TestCase):
+class ClassAPITest(BaseTestCase):
 
   @unittest.skipIf(
       api_implementation.Type() == 'cpp' and api_implementation.Version() == 2,
       'C++ implementation requires a call to MakeDescriptor()')
   def testMakeClassWithNestedDescriptor(self):
     leaf_desc = descriptor.Descriptor('leaf', 'package.parent.child.leaf', '',
                                       containing_type=None, fields=[],
                                       nested_types=[], enum_types=[],
                                       extensions=[])
     child_desc = descriptor.Descriptor('child', 'package.parent.child', '',
@@ skipping 62 matching lines @@
         '        label: LABEL_OPTIONAL'
         '        type: TYPE_UINT32'
         '      }'
         '    }'
         '  }'
         '}')
     file_descriptor = descriptor_pb2.FileDescriptorProto()
     text_format.Merge(file_descriptor_str, file_descriptor)
     return file_descriptor.SerializeToString()
 
+  @testing_refleaks.SkipReferenceLeakChecker('MakeDescriptor is not repeatable')
+  # This test can only run once; the second time, it raises errors about
+  # conflicting message descriptors.
   def testParsingFlatClassWithExplicitClassDeclaration(self):
     """Test that the generated class can parse a flat message."""
     # TODO(xiaofeng): This test fails with cpp implemetnation in the call
     # of six.with_metaclass(). The other two callsites of with_metaclass
     # in this file are both excluded from cpp test, so it might be expected
     # to fail. Need someone more familiar with the python code to take a
     # look at this.
     if api_implementation.Type() != 'python':
       return
     file_descriptor = descriptor_pb2.FileDescriptorProto()
     file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A'))
     msg_descriptor = descriptor.MakeDescriptor(
         file_descriptor.message_type[0])
 
     class MessageClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)):
       DESCRIPTOR = msg_descriptor
     msg = MessageClass()
     msg_str = (
         'flat: 0 '
         'flat: 1 '
         'flat: 2 ')
     text_format.Merge(msg_str, msg)
     self.assertEqual(msg.flat, [0, 1, 2])
 
+  @testing_refleaks.SkipReferenceLeakChecker('MakeDescriptor is not repeatable')
   def testParsingFlatClass(self):
     """Test that the generated class can parse a flat message."""
     file_descriptor = descriptor_pb2.FileDescriptorProto()
     file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('B'))
     msg_descriptor = descriptor.MakeDescriptor(
         file_descriptor.message_type[0])
     msg_class = reflection.MakeClass(msg_descriptor)
     msg = msg_class()
     msg_str = (
         'flat: 0 '
         'flat: 1 '
         'flat: 2 ')
     text_format.Merge(msg_str, msg)
     self.assertEqual(msg.flat, [0, 1, 2])
 
+  @testing_refleaks.SkipReferenceLeakChecker('MakeDescriptor is not repeatable')
   def testParsingNestedClass(self):
     """Test that the generated class can parse a nested message."""
     file_descriptor = descriptor_pb2.FileDescriptorProto()
     file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('C'))
     msg_descriptor = descriptor.MakeDescriptor(
         file_descriptor.message_type[0])
     msg_class = reflection.MakeClass(msg_descriptor)
     msg = msg_class()
     msg_str = (
         'bar {'
         '  baz {'
         '    deep: 4'
         '  }'
         '}')
     text_format.Merge(msg_str, msg)
     self.assertEqual(msg.bar.baz.deep, 4)
 
 if __name__ == '__main__':
   unittest.main()