third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/python/google/protobuf/internal/json_format_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 187 matching lines @@
                    '"boolValue": false,'
                    '"repeatedEnumValue": [],'
                    '"uint64Value": "0",'
                    '"doubleValue": 0,'
                    '"repeatedFloatValue": [],'
                    '"repeatedInt64Value": [],'
                    '"repeatedMessageValue": []}'))
     parsed_message = json_format_proto3_pb2.TestMessage()
     self.CheckParseBack(message, parsed_message)
 
+  def testIntegersRepresentedAsFloat(self):
+    message = json_format_proto3_pb2.TestMessage()
+    json_format.Parse('{"int32Value": -2.147483648e9}', message)
+    self.assertEqual(message.int32_value, -2147483648)
+    json_format.Parse('{"int32Value": 1e5}', message)
+    self.assertEqual(message.int32_value, 100000)
+    json_format.Parse('{"int32Value": 1.0}', message)
+    self.assertEqual(message.int32_value, 1)
+
   def testMapFields(self):
     message = json_format_proto3_pb2.TestMap()
     message.bool_map[True] = 1
     message.bool_map[False] = 2
     message.int32_map[1] = 2
     message.int32_map[2] = 3
     message.int64_map[1] = 2
     message.int64_map[2] = 3
     message.uint32_map[1] = 2
     message.uint32_map[2] = 3
@@ skipping 22 matching lines @@
         '{}')
     message.oneof_int32_value = 0
     self.assertEqual(
         json_format.MessageToJson(message, True),
         '{\n'
         '  "oneofInt32Value": 0\n'
         '}')
     parsed_message = json_format_proto3_pb2.TestOneof()
     self.CheckParseBack(message, parsed_message)
 
+  def testSurrogates(self):
+    # Test correct surrogate handling.
+    message = json_format_proto3_pb2.TestMessage()
+    json_format.Parse('{"stringValue": "\\uD83D\\uDE01"}', message)
+    self.assertEqual(message.string_value,
+                     b'\xF0\x9F\x98\x81'.decode('utf-8', 'strict'))
+
+    # Error case: unpaired high surrogate.
+    self.CheckError(
+        '{"stringValue": "\\uD83D"}',
+        r'Invalid \\uXXXX escape|Unpaired.*surrogate')
+
+    # Unpaired low surrogate.
+    self.CheckError(
+        '{"stringValue": "\\uDE01"}',
+        r'Invalid \\uXXXX escape|Unpaired.*surrogate')
+
   def testTimestampMessage(self):
     message = json_format_proto3_pb2.TestTimestamp()
     message.value.seconds = 0
     message.value.nanos = 0
     message.repeated_value.add().seconds = 20
     message.repeated_value[0].nanos = 1
     message.repeated_value.add().seconds = 0
     message.repeated_value[1].nanos = 10000
     message.repeated_value.add().seconds = 100000000
     message.repeated_value[2].nanos = 0
@@ skipping 144 matching lines @@
     self.CheckParseBack(message, parsed_message)
     # Can't parse back if the Value message is not set.
     message.repeated_value.add()
     self.assertEqual(
         json.loads(json_format.MessageToJson(message, False)),
         json.loads(
             '{'
             '  "value": "hello",'
             '  "repeatedValue": [11.1, false, null, null]'
             '}'))
+    message.Clear()
+    json_format.Parse('{"value": null}', message)
+    self.assertEqual(message.value.WhichOneof('kind'), 'null_value')
 
   def testListValueMessage(self):
     message = json_format_proto3_pb2.TestListValue()
     message.value.values.add().number_value = 11.1
     message.value.values.add().null_value = 0
     message.value.values.add().bool_value = True
     message.value.values.add().string_value = 'hello'
     message.value.values.add().struct_value['name'] = 'Jim'
     message.repeated_value.add().values.add().number_value = 1
     message.repeated_value.add()
@@ skipping 27 matching lines @@
             '    "value": 5678\n'
             '  },\n'
             '  {}],\n'
             '  "value": {\n'
             '    "@type": "type.googleapis.com/proto3.MessageType",\n'
             '    "value": 1234\n'
             '  }\n'
             '}\n'))
     parsed_message = json_format_proto3_pb2.TestAny()
     self.CheckParseBack(message, parsed_message)
+    # Must print @type first
+    test_message = json_format_proto3_pb2.TestMessage(
+        bool_value=True,
+        int32_value=20,
+        int64_value=-20,
+        uint32_value=20,
+        uint64_value=20,
+        double_value=3.14,
+        string_value='foo')
+    message.Clear()
+    message.value.Pack(test_message)
+    self.assertEqual(
+        json_format.MessageToJson(message, False)[0:68],
+        '{\n'
+        '  "value": {\n'
+        '    "@type": "type.googleapis.com/proto3.TestMessage"')
 
   def testWellKnownInAnyMessage(self):
     message = any_pb2.Any()
     int32_value = wrappers_pb2.Int32Value()
     int32_value.value = 1234
     message.Pack(int32_value)
     self.assertEqual(
         json.loads(json_format.MessageToJson(message, True)),
         json.loads(
             '{\n'
@@ skipping 89 matching lines @@
                       '"repeatedFloatValue": null,'
                       '"repeatedDoubleValue": null,'
                       '"repeatedBoolValue": null,'
                       '"repeatedStringValue": null,'
                       '"repeatedBytesValue": null,'
                       '"repeatedMessageValue": null,'
                       '"repeatedEnumValue": null'
                       '}',
                       parsed_message)
     self.assertEqual(message, parsed_message)
+    # Null and {} should have different behavior for sub message.
+    self.assertFalse(parsed_message.HasField('message_value'))
+    json_format.Parse('{"messageValue": {}}', parsed_message)
+    self.assertTrue(parsed_message.HasField('message_value'))
+    # Null is not allowed to be used as an element in repeated field.
     self.assertRaisesRegexp(
         json_format.ParseError,
         'Failed to parse repeatedInt32Value field: '
         'null is not allowed to be used as an element in a repeated field.',
         json_format.Parse,
         '{"repeatedInt32Value":[1, null]}',
         parsed_message)
 
   def testNanFloat(self):
     message = json_format_proto3_pb2.TestMessage()
     message.float_value = float('nan')
     text = '{\n  "floatValue": "NaN"\n}'
     self.assertEqual(json_format.MessageToJson(message), text)
     parsed_message = json_format_proto3_pb2.TestMessage()
     json_format.Parse(text, parsed_message)
     self.assertTrue(math.isnan(parsed_message.float_value))
 
   def testParseEmptyText(self):
     self.CheckError('',
                     r'Failed to load JSON: (Expecting value)|(No JSON).')
 
-  def testParseBadEnumValue(self):
-    self.CheckError(
-        '{"enumValue": 1}',
-        'Enum value must be a string literal with double quotes. '
-        'Type "proto3.EnumType" has no value named 1.')
+  def testParseEnumValue(self):
+    message = json_format_proto3_pb2.TestMessage()
+    text = '{"enumValue": 0}'
+    json_format.Parse(text, message)
+    text = '{"enumValue": 1}'
+    json_format.Parse(text, message)
     self.CheckError(
         '{"enumValue": "baz"}',
-        'Enum value must be a string literal with double quotes. '
-        'Type "proto3.EnumType" has no value named baz.')
+        'Failed to parse enumValue field: Invalid enum value baz '
+        'for enum type proto3.EnumType.')
 
   def testParseBadIdentifer(self):
     self.CheckError('{int32Value: 1}',
                     (r'Failed to load JSON: Expecting property name'
                      r'( enclosed in double quotes)?: line 1'))
     self.CheckError('{"unknownName": 1}',
                     'Message type "proto3.TestMessage" has no field named '
                     '"unknownName".')
 
+  def testIgnoreUnknownField(self):
+    text = '{"unknownName": 1}'
+    parsed_message = json_format_proto3_pb2.TestMessage()
+    json_format.Parse(text, parsed_message, ignore_unknown_fields=True)
+    text = ('{\n'
+            '  "repeatedValue": [ {\n'
+            '    "@type": "type.googleapis.com/proto3.MessageType",\n'
+            '    "unknownName": 1\n'
+            '  }]\n'
+            '}\n')
+    parsed_message = json_format_proto3_pb2.TestAny()
+    json_format.Parse(text, parsed_message, ignore_unknown_fields=True)
+
   def testDuplicateField(self):
     # Duplicate key check is not supported for python2.6
     if sys.version_info < (2, 7):
       return
     self.CheckError('{"int32Value": 1,\n"int32Value":2}',
                     'Failed to load JSON: duplicate key int32Value.')
 
   def testInvalidBoolValue(self):
     self.CheckError('{"boolValue": 1}',
                     'Failed to parse boolValue field: '
                     'Expected true or false without quotes.')
     self.CheckError('{"boolValue": "true"}',
                     'Failed to parse boolValue field: '
                     'Expected true or false without quotes.')
 
   def testInvalidIntegerValue(self):
     message = json_format_proto3_pb2.TestMessage()
     text = '{"int32Value": 0x12345}'
     self.assertRaises(json_format.ParseError,
                       json_format.Parse, text, message)
+    self.CheckError('{"int32Value": 1.5}',
+                    'Failed to parse int32Value field: '
+                    'Couldn\'t parse integer: 1.5.')
     self.CheckError('{"int32Value": 012345}',
                     (r'Failed to load JSON: Expecting \'?,\'? delimiter: '
                      r'line 1.'))
-    self.CheckError('{"int32Value": 1.0}',
-                    'Failed to parse int32Value field: '
-                    'Couldn\'t parse integer: 1.0.')
     self.CheckError('{"int32Value": " 1 "}',
                     'Failed to parse int32Value field: '
                     'Couldn\'t parse integer: " 1 ".')
     self.CheckError('{"int32Value": "1 "}',
                     'Failed to parse int32Value field: '
                     'Couldn\'t parse integer: "1 ".')
     self.CheckError('{"int32Value": 12345678901234567890}',
                     'Failed to parse int32Value field: Value out of range: '
                     '12345678901234567890.')
-    self.CheckError('{"int32Value": 1e5}',
-                    'Failed to parse int32Value field: '
-                    'Couldn\'t parse integer: 100000.0.')
     self.CheckError('{"uint32Value": -1}',
                     'Failed to parse uint32Value field: '
                     'Value out of range: -1.')
 
   def testInvalidFloatValue(self):
     self.CheckError('{"floatValue": "nan"}',
                     'Failed to parse floatValue field: Couldn\'t '
                     'parse float "nan", use "NaN" instead.')
 
   def testInvalidBytesValue(self):
@@ skipping 100 matching lines @@
     self.assertRaisesRegexp(
         TypeError,
         'Can not find message descriptor by type_url: '
         'type.googleapis.com/MessageNotExist.',
         json_format.Parse, text, message)
     # Only last part is to be used: b/25630112
     text = (r'{"@type": "incorrect.googleapis.com/google.protobuf.Int32Value",'
             r'"value": 1234}')
     json_format.Parse(text, message)
 
+  def testPreservingProtoFieldNames(self):
+    message = json_format_proto3_pb2.TestMessage()
+    message.int32_value = 12345
+    self.assertEqual('{\n  "int32Value": 12345\n}',
+                     json_format.MessageToJson(message))
+    self.assertEqual('{\n  "int32_value": 12345\n}',
+                     json_format.MessageToJson(message, False, True))
+
+    # Parsers accept both original proto field names and lowerCamelCase names.
+    message = json_format_proto3_pb2.TestMessage()
+    json_format.Parse('{"int32Value": 54321}', message)
+    self.assertEqual(54321, message.int32_value)
+    json_format.Parse('{"int32_value": 12345}', message)
+    self.assertEqual(12345, message.int32_value)
+
+  def testParseDict(self):
+    expected = 12345
+    js_dict = {'int32Value': expected}
+    message = json_format_proto3_pb2.TestMessage()
+    json_format.ParseDict(js_dict, message)
+    self.assertEqual(expected, message.int32_value)
+
+  def testMessageToDict(self):
+    message = json_format_proto3_pb2.TestMessage()
+    message.int32_value = 12345
+    expected = {'int32Value': 12345}
+    self.assertEqual(expected,
+                     json_format.MessageToDict(message))
+
+  def testJsonName(self):
+    message = json_format_proto3_pb2.TestCustomJsonName()
+    message.value = 12345
+    self.assertEqual('{\n  "@value": 12345\n}',
+                     json_format.MessageToJson(message))
+    parsed_message = json_format_proto3_pb2.TestCustomJsonName()
+    self.CheckParseBack(message, parsed_message)
+
 
 if __name__ == '__main__':
   unittest.main()