third_party/protobuf: Update to HEAD (83d681ee2c)

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

Index: third_party/protobuf/python/google/protobuf/internal/well_known_types_test.py
diff --git a/third_party/protobuf/python/google/protobuf/internal/well_known_types_test.py b/third_party/protobuf/python/google/protobuf/internal/well_known_types_test.py
index 2f32ac9941d889ae68f64a9a3fa398227efada2f..077f630f71252ff72e4c32e48c342099a6f498b0 100644
--- a/third_party/protobuf/python/google/protobuf/internal/well_known_types_test.py
+++ b/third_party/protobuf/python/google/protobuf/internal/well_known_types_test.py
@@ -303,6 +303,25 @@ class TimeUtilTest(TimeUtilTestBase):
         well_known_types.ParseError,
         'Couldn\'t parse duration: 1...2s.',
         message.FromJsonString, '1...2s')
+    text = '-315576000001.000000000s'
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        r'Duration is not valid\: Seconds -315576000001 must be in range'
+        r' \[-315576000000\, 315576000000\].',
+        message.FromJsonString, text)
+    text = '315576000001.000000000s'
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        r'Duration is not valid\: Seconds 315576000001 must be in range'
+        r' \[-315576000000\, 315576000000\].',
+        message.FromJsonString, text)
+    message.seconds = -315576000001
+    message.nanos = 0
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        r'Duration is not valid\: Seconds -315576000001 must be in range'
+        r' \[-315576000000\, 315576000000\].',
+        message.ToJsonString)
 
 
 class FieldMaskTest(unittest.TestCase):
@@ -322,6 +341,20 @@ class FieldMaskTest(unittest.TestCase):
     mask.FromJsonString('foo,bar')
     self.assertEqual(['foo', 'bar'], mask.paths)
 
+    # Test camel case
+    mask.Clear()
+    mask.paths.append('foo_bar')
+    self.assertEqual('fooBar', mask.ToJsonString())
+    mask.paths.append('bar_quz')
+    self.assertEqual('fooBar,barQuz', mask.ToJsonString())
+
+    mask.FromJsonString('')
+    self.assertEqual('', mask.ToJsonString())
+    mask.FromJsonString('fooBar')
+    self.assertEqual(['foo_bar'], mask.paths)
+    mask.FromJsonString('fooBar,barQuz')
+    self.assertEqual(['foo_bar', 'bar_quz'], mask.paths)
+
   def testDescriptorToFieldMask(self):
     mask = field_mask_pb2.FieldMask()
     msg_descriptor = unittest_pb2.TestAllTypes.DESCRIPTOR
@@ -502,17 +535,68 @@ class FieldMaskTest(unittest.TestCase):
     nested_src.payload.repeated_int32.append(1234)
     nested_dst.payload.repeated_int32.append(5678)
     # Repeated fields will be appended by default.
-    mask.FromJsonString('payload.repeated_int32')
+    mask.FromJsonString('payload.repeatedInt32')
     mask.MergeMessage(nested_src, nested_dst)
     self.assertEqual(2, len(nested_dst.payload.repeated_int32))
     self.assertEqual(5678, nested_dst.payload.repeated_int32[0])
     self.assertEqual(1234, nested_dst.payload.repeated_int32[1])
     # Change the behavior to replace repeated fields.
-    mask.FromJsonString('payload.repeated_int32')
+    mask.FromJsonString('payload.repeatedInt32')
     mask.MergeMessage(nested_src, nested_dst, False, True)
     self.assertEqual(1, len(nested_dst.payload.repeated_int32))
     self.assertEqual(1234, nested_dst.payload.repeated_int32[0])
 
+  def testSnakeCaseToCamelCase(self):
+    self.assertEqual('fooBar',
+                     well_known_types._SnakeCaseToCamelCase('foo_bar'))
+    self.assertEqual('FooBar',
+                     well_known_types._SnakeCaseToCamelCase('_foo_bar'))
+    self.assertEqual('foo3Bar',
+                     well_known_types._SnakeCaseToCamelCase('foo3_bar'))
+
+    # No uppercase letter is allowed.
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        'Fail to print FieldMask to Json string: Path name Foo must '
+        'not contain uppercase letters.',
+        well_known_types._SnakeCaseToCamelCase,
+        'Foo')
+    # Any character after a "_" must be a lowercase letter.
+    #   1. "_" cannot be followed by another "_".
+    #   2. "_" cannot be followed by a digit.
+    #   3. "_" cannot appear as the last character.
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        'Fail to print FieldMask to Json string: The character after a '
+        '"_" must be a lowercase letter in path name foo__bar.',
+        well_known_types._SnakeCaseToCamelCase,
+        'foo__bar')
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        'Fail to print FieldMask to Json string: The character after a '
+        '"_" must be a lowercase letter in path name foo_3bar.',
+        well_known_types._SnakeCaseToCamelCase,
+        'foo_3bar')
+    self.assertRaisesRegexp(
+        well_known_types.Error,
+        'Fail to print FieldMask to Json string: Trailing "_" in path '
+        'name foo_bar_.',
+        well_known_types._SnakeCaseToCamelCase,
+        'foo_bar_')
+
+  def testCamelCaseToSnakeCase(self):
+    self.assertEqual('foo_bar',
+                     well_known_types._CamelCaseToSnakeCase('fooBar'))
+    self.assertEqual('_foo_bar',
+                     well_known_types._CamelCaseToSnakeCase('FooBar'))
+    self.assertEqual('foo3_bar',
+                     well_known_types._CamelCaseToSnakeCase('foo3Bar'))
+    self.assertRaisesRegexp(
+        well_known_types.ParseError,
+        'Fail to parse FieldMask: Path name foo_bar must not contain "_"s.',
+        well_known_types._CamelCaseToSnakeCase,
+        'foo_bar')
+
 
 class StructTest(unittest.TestCase):
 
@@ -529,52 +613,52 @@ class StructTest(unittest.TestCase):
     struct_list.add_struct()['subkey2'] = 9
 
     self.assertTrue(isinstance(struct, well_known_types.Struct))
-    self.assertEquals(5, struct['key1'])
-    self.assertEquals('abc', struct['key2'])
+    self.assertEqual(5, struct['key1'])
+    self.assertEqual('abc', struct['key2'])
     self.assertIs(True, struct['key3'])
-    self.assertEquals(11, struct['key4']['subkey'])
+    self.assertEqual(11, struct['key4']['subkey'])
     inner_struct = struct_class()
     inner_struct['subkey2'] = 9
-    self.assertEquals([6, 'seven', True, False, None, inner_struct],
-                      list(struct['key5'].items()))
+    self.assertEqual([6, 'seven', True, False, None, inner_struct],
+                     list(struct['key5'].items()))
 
     serialized = struct.SerializeToString()
 
     struct2 = struct_pb2.Struct()
     struct2.ParseFromString(serialized)
 
-    self.assertEquals(struct, struct2)
+    self.assertEqual(struct, struct2)
 
     self.assertTrue(isinstance(struct2, well_known_types.Struct))
-    self.assertEquals(5, struct2['key1'])
-    self.assertEquals('abc', struct2['key2'])
+    self.assertEqual(5, struct2['key1'])
+    self.assertEqual('abc', struct2['key2'])
     self.assertIs(True, struct2['key3'])
-    self.assertEquals(11, struct2['key4']['subkey'])
-    self.assertEquals([6, 'seven', True, False, None, inner_struct],
-                      list(struct2['key5'].items()))
+    self.assertEqual(11, struct2['key4']['subkey'])
+    self.assertEqual([6, 'seven', True, False, None, inner_struct],
+                     list(struct2['key5'].items()))
 
     struct_list = struct2['key5']
-    self.assertEquals(6, struct_list[0])
-    self.assertEquals('seven', struct_list[1])
-    self.assertEquals(True, struct_list[2])
-    self.assertEquals(False, struct_list[3])
-    self.assertEquals(None, struct_list[4])
-    self.assertEquals(inner_struct, struct_list[5])
+    self.assertEqual(6, struct_list[0])
+    self.assertEqual('seven', struct_list[1])
+    self.assertEqual(True, struct_list[2])
+    self.assertEqual(False, struct_list[3])
+    self.assertEqual(None, struct_list[4])
+    self.assertEqual(inner_struct, struct_list[5])
 
     struct_list[1] = 7
-    self.assertEquals(7, struct_list[1])
+    self.assertEqual(7, struct_list[1])
 
     struct_list.add_list().extend([1, 'two', True, False, None])
-    self.assertEquals([1, 'two', True, False, None],
-                      list(struct_list[6].items()))
+    self.assertEqual([1, 'two', True, False, None],
+                     list(struct_list[6].items()))
 
     text_serialized = str(struct)
     struct3 = struct_pb2.Struct()
     text_format.Merge(text_serialized, struct3)
-    self.assertEquals(struct, struct3)
+    self.assertEqual(struct, struct3)
 
     struct.get_or_create_struct('key3')['replace'] = 12
-    self.assertEquals(12, struct['key3']['replace'])
+    self.assertEqual(12, struct['key3']['replace'])
 
 
 class AnyTest(unittest.TestCase):