google/protobuf/internal/text_format_test.py
Go to the documentation of this file.
1 #! /usr/bin/env python
2 # -*- coding: utf-8 -*-
3 #
4 # Protocol Buffers - Google's data interchange format
5 # Copyright 2008 Google Inc. All rights reserved.
6 # https://developers.google.com/protocol-buffers/
7 #
8 # Redistribution and use in source and binary forms, with or without
9 # modification, are permitted provided that the following conditions are
10 # met:
11 #
12 # * Redistributions of source code must retain the above copyright
13 # notice, this list of conditions and the following disclaimer.
14 # * Redistributions in binary form must reproduce the above
15 # copyright notice, this list of conditions and the following disclaimer
16 # in the documentation and/or other materials provided with the
17 # distribution.
18 # * Neither the name of Google Inc. nor the names of its
19 # contributors may be used to endorse or promote products derived from
20 # this software without specific prior written permission.
21 #
22 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 
34 """Test for google.protobuf.text_format."""
35 
36 import io
37 import math
38 import re
39 import string
40 import textwrap
41 
42 import six
43 
44 # pylint: disable=g-import-not-at-top
45 try:
46  import unittest2 as unittest # PY26
47 except ImportError:
48  import unittest
49 
50 from google.protobuf import any_pb2
51 from google.protobuf import any_test_pb2
52 from google.protobuf import map_unittest_pb2
53 from google.protobuf import unittest_custom_options_pb2
54 from google.protobuf import unittest_mset_pb2
55 from google.protobuf import unittest_pb2
56 from google.protobuf import unittest_proto3_arena_pb2
57 from google.protobuf import descriptor_pb2
58 from google.protobuf.internal import any_test_pb2 as test_extend_any
59 from google.protobuf.internal import message_set_extensions_pb2
60 from google.protobuf.internal import test_util
61 from google.protobuf import descriptor_pool
62 from google.protobuf import text_format
63 from google.protobuf.internal import _parameterized
64 # pylint: enable=g-import-not-at-top
65 
66 
67 # Low-level nuts-n-bolts tests.
68 class SimpleTextFormatTests(unittest.TestCase):
69 
70  # The members of _QUOTES are formatted into a regexp template that
71  # expects single characters. Therefore it's an error (in addition to being
72  # non-sensical in the first place) to try to specify a "quote mark" that is
73  # more than one character.
74  def testQuoteMarksAreSingleChars(self):
75  for quote in text_format._QUOTES:
76  self.assertEqual(1, len(quote))
77 
78 
79 # Base class with some common functionality.
80 class TextFormatBase(unittest.TestCase):
81 
82  def ReadGolden(self, golden_filename):
83  with test_util.GoldenFile(golden_filename) as f:
84  return (f.readlines() if str is bytes else # PY3
85  [golden_line.decode('utf-8') for golden_line in f])
86 
87  def CompareToGoldenFile(self, text, golden_filename):
88  golden_lines = self.ReadGolden(golden_filename)
89  self.assertMultiLineEqual(text, ''.join(golden_lines))
90 
91  def CompareToGoldenText(self, text, golden_text):
92  self.assertEqual(text, golden_text)
93 
94  def RemoveRedundantZeros(self, text):
95  # Some platforms print 1e+5 as 1e+005. This is fine, but we need to remove
96  # these zeros in order to match the golden file.
97  text = text.replace('e+0','e+').replace('e+0','e+') \
98  .replace('e-0','e-').replace('e-0','e-')
99  # Floating point fields are printed with .0 suffix even if they are
100  # actualy integer numbers.
101  text = re.compile(r'\.0$', re.MULTILINE).sub('', text)
102  return text
103 
104 
105 @_parameterized.parameters(unittest_pb2, unittest_proto3_arena_pb2)
106 class TextFormatMessageToStringTests(TextFormatBase):
107 
108  def testPrintExotic(self, message_module):
109  message = message_module.TestAllTypes()
110  message.repeated_int64.append(-9223372036854775808)
111  message.repeated_uint64.append(18446744073709551615)
112  message.repeated_double.append(123.456)
113  message.repeated_double.append(1.23e22)
114  message.repeated_double.append(1.23e-18)
115  message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
116  message.repeated_string.append(u'\u00fc\ua71f')
117  self.CompareToGoldenText(
118  self.RemoveRedundantZeros(text_format.MessageToString(message)),
119  'repeated_int64: -9223372036854775808\n'
120  'repeated_uint64: 18446744073709551615\n'
121  'repeated_double: 123.456\n'
122  'repeated_double: 1.23e+22\n'
123  'repeated_double: 1.23e-18\n'
124  'repeated_string:'
125  ' "\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n'
126  'repeated_string: "\\303\\274\\352\\234\\237"\n')
127 
128  def testPrintExoticUnicodeSubclass(self, message_module):
129 
130  class UnicodeSub(six.text_type):
131  pass
132 
133  message = message_module.TestAllTypes()
134  message.repeated_string.append(UnicodeSub(u'\u00fc\ua71f'))
135  self.CompareToGoldenText(
136  text_format.MessageToString(message),
137  'repeated_string: "\\303\\274\\352\\234\\237"\n')
138 
139  def testPrintNestedMessageAsOneLine(self, message_module):
140  message = message_module.TestAllTypes()
141  msg = message.repeated_nested_message.add()
142  msg.bb = 42
143  self.CompareToGoldenText(
144  text_format.MessageToString(message, as_one_line=True),
145  'repeated_nested_message { bb: 42 }')
146 
147  def testPrintRepeatedFieldsAsOneLine(self, message_module):
148  message = message_module.TestAllTypes()
149  message.repeated_int32.append(1)
150  message.repeated_int32.append(1)
151  message.repeated_int32.append(3)
152  message.repeated_string.append('Google')
153  message.repeated_string.append('Zurich')
154  self.CompareToGoldenText(
155  text_format.MessageToString(message, as_one_line=True),
156  'repeated_int32: 1 repeated_int32: 1 repeated_int32: 3 '
157  'repeated_string: "Google" repeated_string: "Zurich"')
158 
159  def VerifyPrintShortFormatRepeatedFields(self, message_module, as_one_line):
160  message = message_module.TestAllTypes()
161  message.repeated_int32.append(1)
162  message.repeated_string.append('Google')
163  message.repeated_string.append('Hello,World')
164  message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_FOO)
165  message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAR)
166  message.repeated_foreign_enum.append(unittest_pb2.FOREIGN_BAZ)
167  message.optional_nested_message.bb = 3
168  for i in (21, 32):
169  msg = message.repeated_nested_message.add()
170  msg.bb = i
171  expected_ascii = (
172  'optional_nested_message {\n bb: 3\n}\n'
173  'repeated_int32: [1]\n'
174  'repeated_string: "Google"\n'
175  'repeated_string: "Hello,World"\n'
176  'repeated_nested_message {\n bb: 21\n}\n'
177  'repeated_nested_message {\n bb: 32\n}\n'
178  'repeated_foreign_enum: [FOREIGN_FOO, FOREIGN_BAR, FOREIGN_BAZ]\n')
179  if as_one_line:
180  expected_ascii = expected_ascii.replace('\n', ' ')
181  expected_ascii = re.sub(r'\s+', ' ', expected_ascii)
182  expected_ascii = re.sub(r'\s$', '', expected_ascii)
183 
184  actual_ascii = text_format.MessageToString(
185  message, use_short_repeated_primitives=True,
186  as_one_line=as_one_line)
187  self.CompareToGoldenText(actual_ascii, expected_ascii)
188  parsed_message = message_module.TestAllTypes()
189  text_format.Parse(actual_ascii, parsed_message)
190  self.assertEqual(parsed_message, message)
191 
192  def testPrintShortFormatRepeatedFields(self, message_module):
193  self.VerifyPrintShortFormatRepeatedFields(message_module, False)
194  self.VerifyPrintShortFormatRepeatedFields(message_module, True)
195 
196  def testPrintNestedNewLineInStringAsOneLine(self, message_module):
197  message = message_module.TestAllTypes()
198  message.optional_string = 'a\nnew\nline'
199  self.CompareToGoldenText(
200  text_format.MessageToString(message, as_one_line=True),
201  'optional_string: "a\\nnew\\nline"')
202 
203  def testPrintExoticAsOneLine(self, message_module):
204  message = message_module.TestAllTypes()
205  message.repeated_int64.append(-9223372036854775808)
206  message.repeated_uint64.append(18446744073709551615)
207  message.repeated_double.append(123.456)
208  message.repeated_double.append(1.23e22)
209  message.repeated_double.append(1.23e-18)
210  message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
211  message.repeated_string.append(u'\u00fc\ua71f')
212  self.CompareToGoldenText(
213  self.RemoveRedundantZeros(text_format.MessageToString(
214  message, as_one_line=True)),
215  'repeated_int64: -9223372036854775808'
216  ' repeated_uint64: 18446744073709551615'
217  ' repeated_double: 123.456'
218  ' repeated_double: 1.23e+22'
219  ' repeated_double: 1.23e-18'
220  ' repeated_string: '
221  '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""'
222  ' repeated_string: "\\303\\274\\352\\234\\237"')
223 
224  def testRoundTripExoticAsOneLine(self, message_module):
225  message = message_module.TestAllTypes()
226  message.repeated_int64.append(-9223372036854775808)
227  message.repeated_uint64.append(18446744073709551615)
228  message.repeated_double.append(123.456)
229  message.repeated_double.append(1.23e22)
230  message.repeated_double.append(1.23e-18)
231  message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
232  message.repeated_string.append(u'\u00fc\ua71f')
233 
234  # Test as_utf8 = False.
235  wire_text = text_format.MessageToString(message,
236  as_one_line=True,
237  as_utf8=False)
238  parsed_message = message_module.TestAllTypes()
239  r = text_format.Parse(wire_text, parsed_message)
240  self.assertIs(r, parsed_message)
241  self.assertEqual(message, parsed_message)
242 
243  # Test as_utf8 = True.
244  wire_text = text_format.MessageToString(message,
245  as_one_line=True,
246  as_utf8=True)
247  parsed_message = message_module.TestAllTypes()
248  r = text_format.Parse(wire_text, parsed_message)
249  self.assertIs(r, parsed_message)
250  self.assertEqual(message, parsed_message,
251  '\n%s != %s' % (message, parsed_message))
252 
253  def testPrintRawUtf8String(self, message_module):
254  message = message_module.TestAllTypes()
255  message.repeated_string.append(u'\u00fc\t\ua71f')
256  text = text_format.MessageToString(message, as_utf8=True)
257  golden_unicode = u'repeated_string: "\u00fc\\t\ua71f"\n'
258  golden_text = golden_unicode if six.PY3 else golden_unicode.encode('utf-8')
259  # MessageToString always returns a native str.
260  self.CompareToGoldenText(text, golden_text)
261  parsed_message = message_module.TestAllTypes()
262  text_format.Parse(text, parsed_message)
263  self.assertEqual(
264  message, parsed_message, '\n%s != %s (%s != %s)' %
265  (message, parsed_message, message.repeated_string[0],
266  parsed_message.repeated_string[0]))
267 
268  def testPrintFloatFormat(self, message_module):
269  # Check that float_format argument is passed to sub-message formatting.
270  message = message_module.NestedTestAllTypes()
271  message.payload.optional_float = 1.25
272  # Check rounding at 15 significant digits
273  message.payload.optional_double = -.000003456789012345678
274  # Check no decimal point.
275  message.payload.repeated_float.append(-5642)
276  # Check no trailing zeros.
277  message.payload.repeated_double.append(.000078900)
278  formatted_fields = ['optional_float: 1.25',
279  'optional_double: -3.45678901234568e-6',
280  'repeated_float: -5642', 'repeated_double: 7.89e-5']
281  text_message = text_format.MessageToString(message, float_format='.15g')
282  self.CompareToGoldenText(
283  self.RemoveRedundantZeros(text_message),
284  'payload {{\n {0}\n {1}\n {2}\n {3}\n}}\n'.format(
285  *formatted_fields))
286  # as_one_line=True is a separate code branch where float_format is passed.
287  text_message = text_format.MessageToString(message,
288  as_one_line=True,
289  float_format='.15g')
290  self.CompareToGoldenText(
291  self.RemoveRedundantZeros(text_message),
292  'payload {{ {0} {1} {2} {3} }}'.format(*formatted_fields))
293 
294  # 32-bit 1.2 is noisy when extended to 64-bit:
295  # >>> struct.unpack('f', struct.pack('f', 1.2))[0]
296  # 1.2000000476837158
297  # TODO(jieluo): change to 1.2 with cl/241634942.
298  message.payload.optional_float = 1.2000000476837158
299  formatted_fields = ['optional_float: 1.2',
300  'optional_double: -3.45678901234568e-6',
301  'repeated_float: -5642', 'repeated_double: 7.89e-5']
302  text_message = text_format.MessageToString(message, float_format='.7g',
303  double_format='.15g')
304  self.CompareToGoldenText(
305  self.RemoveRedundantZeros(text_message),
306  'payload {{\n {0}\n {1}\n {2}\n {3}\n}}\n'.format(
307  *formatted_fields))
308 
309  # Test only set float_format affect both float and double fields.
310  formatted_fields = ['optional_float: 1.2',
311  'optional_double: -3.456789e-6',
312  'repeated_float: -5642', 'repeated_double: 7.89e-5']
313  text_message = text_format.MessageToString(message, float_format='.7g')
314  self.CompareToGoldenText(
315  self.RemoveRedundantZeros(text_message),
316  'payload {{\n {0}\n {1}\n {2}\n {3}\n}}\n'.format(
317  *formatted_fields))
318 
319  # Test default float_format has 8 valid digits.
320  message.payload.optional_float = 1.2345678912
321  message.payload.optional_double = 1.2345678912
322  formatted_fields = ['optional_float: 1.2345679',
323  'optional_double: 1.2345678912',
324  'repeated_float: -5642', 'repeated_double: 7.89e-5']
325  text_message = text_format.MessageToString(message)
326  self.CompareToGoldenText(
327  self.RemoveRedundantZeros(text_message),
328  'payload {{\n {0}\n {1}\n {2}\n {3}\n}}\n'.format(
329  *formatted_fields))
330 
331  def testMessageToString(self, message_module):
332  message = message_module.ForeignMessage()
333  message.c = 123
334  self.assertEqual('c: 123\n', str(message))
335 
336  def testMessageToStringUnicode(self, message_module):
337  golden_unicode = u'Á short desçription and a 🍌.'
338  golden_bytes = golden_unicode.encode('utf-8')
339  message = message_module.TestAllTypes()
340  message.optional_string = golden_unicode
341  message.optional_bytes = golden_bytes
342  text = text_format.MessageToString(message, as_utf8=True)
343  golden_message = textwrap.dedent(
344  'optional_string: "Á short desçription and a 🍌."\n'
345  'optional_bytes: '
346  r'"\303\201 short des\303\247ription and a \360\237\215\214."'
347  '\n')
348  self.CompareToGoldenText(text, golden_message)
349 
350  def testMessageToStringASCII(self, message_module):
351  golden_unicode = u'Á short desçription and a 🍌.'
352  golden_bytes = golden_unicode.encode('utf-8')
353  message = message_module.TestAllTypes()
354  message.optional_string = golden_unicode
355  message.optional_bytes = golden_bytes
356  text = text_format.MessageToString(message, as_utf8=False) # ASCII
357  golden_message = (
358  'optional_string: '
359  r'"\303\201 short des\303\247ription and a \360\237\215\214."'
360  '\n'
361  'optional_bytes: '
362  r'"\303\201 short des\303\247ription and a \360\237\215\214."'
363  '\n')
364  self.CompareToGoldenText(text, golden_message)
365 
366  def testPrintField(self, message_module):
367  message = message_module.TestAllTypes()
368  field = message.DESCRIPTOR.fields_by_name['optional_float']
369  value = message.optional_float
370  out = text_format.TextWriter(False)
371  text_format.PrintField(field, value, out)
372  self.assertEqual('optional_float: 0.0\n', out.getvalue())
373  out.close()
374  # Test Printer
375  out = text_format.TextWriter(False)
376  printer = text_format._Printer(out)
377  printer.PrintField(field, value)
378  self.assertEqual('optional_float: 0.0\n', out.getvalue())
379  out.close()
380 
381  def testPrintFieldValue(self, message_module):
382  message = message_module.TestAllTypes()
383  field = message.DESCRIPTOR.fields_by_name['optional_float']
384  value = message.optional_float
385  out = text_format.TextWriter(False)
386  text_format.PrintFieldValue(field, value, out)
387  self.assertEqual('0.0', out.getvalue())
388  out.close()
389  # Test Printer
390  out = text_format.TextWriter(False)
391  printer = text_format._Printer(out)
392  printer.PrintFieldValue(field, value)
393  self.assertEqual('0.0', out.getvalue())
394  out.close()
395 
396  def testCustomOptions(self, message_module):
397  message_descriptor = (unittest_custom_options_pb2.
398  TestMessageWithCustomOptions.DESCRIPTOR)
399  message_proto = descriptor_pb2.DescriptorProto()
400  message_descriptor.CopyToProto(message_proto)
401  expected_text = (
402  'name: "TestMessageWithCustomOptions"\n'
403  'field {\n'
404  ' name: "field1"\n'
405  ' number: 1\n'
406  ' label: LABEL_OPTIONAL\n'
407  ' type: TYPE_STRING\n'
408  ' options {\n'
409  ' ctype: CORD\n'
410  ' [protobuf_unittest.field_opt1]: 8765432109\n'
411  ' }\n'
412  '}\n'
413  'field {\n'
414  ' name: "oneof_field"\n'
415  ' number: 2\n'
416  ' label: LABEL_OPTIONAL\n'
417  ' type: TYPE_INT32\n'
418  ' oneof_index: 0\n'
419  '}\n'
420  'enum_type {\n'
421  ' name: "AnEnum"\n'
422  ' value {\n'
423  ' name: "ANENUM_VAL1"\n'
424  ' number: 1\n'
425  ' }\n'
426  ' value {\n'
427  ' name: "ANENUM_VAL2"\n'
428  ' number: 2\n'
429  ' options {\n'
430  ' [protobuf_unittest.enum_value_opt1]: 123\n'
431  ' }\n'
432  ' }\n'
433  ' options {\n'
434  ' [protobuf_unittest.enum_opt1]: -789\n'
435  ' }\n'
436  '}\n'
437  'options {\n'
438  ' message_set_wire_format: false\n'
439  ' [protobuf_unittest.message_opt1]: -56\n'
440  '}\n'
441  'oneof_decl {\n'
442  ' name: "AnOneof"\n'
443  ' options {\n'
444  ' [protobuf_unittest.oneof_opt1]: -99\n'
445  ' }\n'
446  '}\n')
447  self.assertEqual(expected_text,
448  text_format.MessageToString(message_proto))
449  parsed_proto = descriptor_pb2.DescriptorProto()
450  text_format.Parse(expected_text, parsed_proto)
451  self.assertEqual(message_proto, parsed_proto)
452 
453 
454 @_parameterized.parameters(unittest_pb2, unittest_proto3_arena_pb2)
455 class TextFormatMessageToTextBytesTests(TextFormatBase):
456 
457  def testMessageToBytes(self, message_module):
458  message = message_module.ForeignMessage()
459  message.c = 123
460  self.assertEqual(b'c: 123\n', text_format.MessageToBytes(message))
461 
462  def testRawUtf8RoundTrip(self, message_module):
463  message = message_module.TestAllTypes()
464  message.repeated_string.append(u'\u00fc\t\ua71f')
465  utf8_text = text_format.MessageToBytes(message, as_utf8=True)
466  golden_bytes = b'repeated_string: "\xc3\xbc\\t\xea\x9c\x9f"\n'
467  self.CompareToGoldenText(utf8_text, golden_bytes)
468  parsed_message = message_module.TestAllTypes()
469  text_format.Parse(utf8_text, parsed_message)
470  self.assertEqual(
471  message, parsed_message, '\n%s != %s (%s != %s)' %
472  (message, parsed_message, message.repeated_string[0],
473  parsed_message.repeated_string[0]))
474 
475  def testEscapedUtf8ASCIIRoundTrip(self, message_module):
476  message = message_module.TestAllTypes()
477  message.repeated_string.append(u'\u00fc\t\ua71f')
478  ascii_text = text_format.MessageToBytes(message) # as_utf8=False default
479  golden_bytes = b'repeated_string: "\\303\\274\\t\\352\\234\\237"\n'
480  self.CompareToGoldenText(ascii_text, golden_bytes)
481  parsed_message = message_module.TestAllTypes()
482  text_format.Parse(ascii_text, parsed_message)
483  self.assertEqual(
484  message, parsed_message, '\n%s != %s (%s != %s)' %
485  (message, parsed_message, message.repeated_string[0],
486  parsed_message.repeated_string[0]))
487 
488 
489 @_parameterized.parameters(unittest_pb2, unittest_proto3_arena_pb2)
490 class TextFormatParserTests(TextFormatBase):
491 
492  def testParseAllFields(self, message_module):
493  message = message_module.TestAllTypes()
494  test_util.SetAllFields(message)
495  ascii_text = text_format.MessageToString(message)
496 
497  parsed_message = message_module.TestAllTypes()
498  text_format.Parse(ascii_text, parsed_message)
499  self.assertEqual(message, parsed_message)
500  if message_module is unittest_pb2:
501  test_util.ExpectAllFieldsSet(self, message)
502 
503  def testParseAndMergeUtf8(self, message_module):
504  message = message_module.TestAllTypes()
505  test_util.SetAllFields(message)
506  ascii_text = text_format.MessageToString(message)
507  ascii_text = ascii_text.encode('utf-8')
508 
509  parsed_message = message_module.TestAllTypes()
510  text_format.Parse(ascii_text, parsed_message)
511  self.assertEqual(message, parsed_message)
512  if message_module is unittest_pb2:
513  test_util.ExpectAllFieldsSet(self, message)
514 
515  parsed_message.Clear()
516  text_format.Merge(ascii_text, parsed_message)
517  self.assertEqual(message, parsed_message)
518  if message_module is unittest_pb2:
519  test_util.ExpectAllFieldsSet(self, message)
520 
521  msg2 = message_module.TestAllTypes()
522  text = (u'optional_string: "café"')
523  text_format.Merge(text, msg2)
524  self.assertEqual(msg2.optional_string, u'café')
525  msg2.Clear()
526  self.assertEqual(msg2.optional_string, u'')
527  text_format.Parse(text, msg2)
528  self.assertEqual(msg2.optional_string, u'café')
529 
530  def testParseDoubleToFloat(self, message_module):
531  message = message_module.TestAllTypes()
532  text = ('repeated_float: 3.4028235e+39\n'
533  'repeated_float: 1.4028235e-39\n')
534  text_format.Parse(text, message)
535  self.assertEqual(message.repeated_float[0], float('inf'))
536  self.assertAlmostEqual(message.repeated_float[1], 1.4028235e-39)
537 
538  def testParseExotic(self, message_module):
539  message = message_module.TestAllTypes()
540  text = ('repeated_int64: -9223372036854775808\n'
541  'repeated_uint64: 18446744073709551615\n'
542  'repeated_double: 123.456\n'
543  'repeated_double: 1.23e+22\n'
544  'repeated_double: 1.23e-18\n'
545  'repeated_string: \n'
546  '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n'
547  'repeated_string: "foo" \'corge\' "grault"\n'
548  'repeated_string: "\\303\\274\\352\\234\\237"\n'
549  'repeated_string: "\\xc3\\xbc"\n'
550  'repeated_string: "\xc3\xbc"\n')
551  text_format.Parse(text, message)
552 
553  self.assertEqual(-9223372036854775808, message.repeated_int64[0])
554  self.assertEqual(18446744073709551615, message.repeated_uint64[0])
555  self.assertEqual(123.456, message.repeated_double[0])
556  self.assertEqual(1.23e22, message.repeated_double[1])
557  self.assertEqual(1.23e-18, message.repeated_double[2])
558  self.assertEqual('\000\001\a\b\f\n\r\t\v\\\'"', message.repeated_string[0])
559  self.assertEqual('foocorgegrault', message.repeated_string[1])
560  self.assertEqual(u'\u00fc\ua71f', message.repeated_string[2])
561  self.assertEqual(u'\u00fc', message.repeated_string[3])
562 
563  def testParseTrailingCommas(self, message_module):
564  message = message_module.TestAllTypes()
565  text = ('repeated_int64: 100;\n'
566  'repeated_int64: 200;\n'
567  'repeated_int64: 300,\n'
568  'repeated_string: "one",\n'
569  'repeated_string: "two";\n')
570  text_format.Parse(text, message)
571 
572  self.assertEqual(100, message.repeated_int64[0])
573  self.assertEqual(200, message.repeated_int64[1])
574  self.assertEqual(300, message.repeated_int64[2])
575  self.assertEqual(u'one', message.repeated_string[0])
576  self.assertEqual(u'two', message.repeated_string[1])
577 
578  def testParseRepeatedScalarShortFormat(self, message_module):
579  message = message_module.TestAllTypes()
580  text = ('repeated_int64: [100, 200];\n'
581  'repeated_int64: []\n'
582  'repeated_int64: 300,\n'
583  'repeated_string: ["one", "two"];\n')
584  text_format.Parse(text, message)
585 
586  self.assertEqual(100, message.repeated_int64[0])
587  self.assertEqual(200, message.repeated_int64[1])
588  self.assertEqual(300, message.repeated_int64[2])
589  self.assertEqual(u'one', message.repeated_string[0])
590  self.assertEqual(u'two', message.repeated_string[1])
591 
592  def testParseRepeatedMessageShortFormat(self, message_module):
593  message = message_module.TestAllTypes()
594  text = ('repeated_nested_message: [{bb: 100}, {bb: 200}],\n'
595  'repeated_nested_message: {bb: 300}\n'
596  'repeated_nested_message [{bb: 400}];\n')
597  text_format.Parse(text, message)
598 
599  self.assertEqual(100, message.repeated_nested_message[0].bb)
600  self.assertEqual(200, message.repeated_nested_message[1].bb)
601  self.assertEqual(300, message.repeated_nested_message[2].bb)
602  self.assertEqual(400, message.repeated_nested_message[3].bb)
603 
604  def testParseEmptyText(self, message_module):
605  message = message_module.TestAllTypes()
606  text = ''
607  text_format.Parse(text, message)
608  self.assertEqual(message_module.TestAllTypes(), message)
609 
610  def testParseInvalidUtf8(self, message_module):
611  message = message_module.TestAllTypes()
612  text = 'repeated_string: "\\xc3\\xc3"'
613  with self.assertRaises(text_format.ParseError) as e:
614  text_format.Parse(text, message)
615  self.assertEqual(e.exception.GetLine(), 1)
616  self.assertEqual(e.exception.GetColumn(), 28)
617 
618  def testParseSingleWord(self, message_module):
619  message = message_module.TestAllTypes()
620  text = 'foo'
621  six.assertRaisesRegex(self, text_format.ParseError, (
622  r'1:1 : Message type "\w+.TestAllTypes" has no field named '
623  r'"foo".'), text_format.Parse, text, message)
624 
625  def testParseUnknownField(self, message_module):
626  message = message_module.TestAllTypes()
627  text = 'unknown_field: 8\n'
628  six.assertRaisesRegex(self, text_format.ParseError, (
629  r'1:1 : Message type "\w+.TestAllTypes" has no field named '
630  r'"unknown_field".'), text_format.Parse, text, message)
631  text = ('optional_int32: 123\n'
632  'unknown_field: 8\n'
633  'optional_nested_message { bb: 45 }')
634  text_format.Parse(text, message, allow_unknown_field=True)
635  self.assertEqual(message.optional_nested_message.bb, 45)
636  self.assertEqual(message.optional_int32, 123)
637 
638  def testParseBadEnumValue(self, message_module):
639  message = message_module.TestAllTypes()
640  text = 'optional_nested_enum: BARR'
641  six.assertRaisesRegex(self, text_format.ParseError,
642  (r'1:23 : \'optional_nested_enum: BARR\': '
643  r'Enum type "\w+.TestAllTypes.NestedEnum" '
644  r'has no value named BARR.'), text_format.Parse,
645  text, message)
646 
647  def testParseBadIntValue(self, message_module):
648  message = message_module.TestAllTypes()
649  text = 'optional_int32: bork'
650  six.assertRaisesRegex(self, text_format.ParseError,
651  ('1:17 : \'optional_int32: bork\': '
652  'Couldn\'t parse integer: bork'),
653  text_format.Parse, text, message)
654 
655  def testParseStringFieldUnescape(self, message_module):
656  message = message_module.TestAllTypes()
657  text = r'''repeated_string: "\xf\x62"
658  repeated_string: "\\xf\\x62"
659  repeated_string: "\\\xf\\\x62"
660  repeated_string: "\\\\xf\\\\x62"
661  repeated_string: "\\\\\xf\\\\\x62"
662  repeated_string: "\x5cx20"'''
663 
664  text_format.Parse(text, message)
665 
666  SLASH = '\\'
667  self.assertEqual('\x0fb', message.repeated_string[0])
668  self.assertEqual(SLASH + 'xf' + SLASH + 'x62', message.repeated_string[1])
669  self.assertEqual(SLASH + '\x0f' + SLASH + 'b', message.repeated_string[2])
670  self.assertEqual(SLASH + SLASH + 'xf' + SLASH + SLASH + 'x62',
671  message.repeated_string[3])
672  self.assertEqual(SLASH + SLASH + '\x0f' + SLASH + SLASH + 'b',
673  message.repeated_string[4])
674  self.assertEqual(SLASH + 'x20', message.repeated_string[5])
675 
676  def testParseOneof(self, message_module):
677  m = message_module.TestAllTypes()
678  m.oneof_uint32 = 11
679  m2 = message_module.TestAllTypes()
680  text_format.Parse(text_format.MessageToString(m), m2)
681  self.assertEqual('oneof_uint32', m2.WhichOneof('oneof_field'))
682 
683  def testParseMultipleOneof(self, message_module):
684  m_string = '\n'.join(['oneof_uint32: 11', 'oneof_string: "foo"'])
685  m2 = message_module.TestAllTypes()
686  with six.assertRaisesRegex(self, text_format.ParseError,
687  ' is specified along with field '):
688  text_format.Parse(m_string, m2)
689 
690  # This example contains non-ASCII codepoint unicode data as literals
691  # which should come through as utf-8 for bytes, and as the unicode
692  # itself for string fields. It also demonstrates escaped binary data.
693  # The ur"" string prefix is unfortunately missing from Python 3
694  # so we resort to double escaping our \s so that they come through.
695  _UNICODE_SAMPLE = u"""
696  optional_bytes: 'Á short desçription'
697  optional_string: 'Á short desçription'
698  repeated_bytes: '\\303\\201 short des\\303\\247ription'
699  repeated_bytes: '\\x12\\x34\\x56\\x78\\x90\\xab\\xcd\\xef'
700  repeated_string: '\\xd0\\x9f\\xd1\\x80\\xd0\\xb8\\xd0\\xb2\\xd0\\xb5\\xd1\\x82'
701  """
702  _BYTES_SAMPLE = _UNICODE_SAMPLE.encode('utf-8')
703  _GOLDEN_UNICODE = u'Á short desçription'
704  _GOLDEN_BYTES = _GOLDEN_UNICODE.encode('utf-8')
705  _GOLDEN_BYTES_1 = b'\x12\x34\x56\x78\x90\xab\xcd\xef'
706  _GOLDEN_STR_0 = u'Привет'
707 
708  def testParseUnicode(self, message_module):
709  m = message_module.TestAllTypes()
710  text_format.Parse(self._UNICODE_SAMPLE, m)
711  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
712  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
713  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
714  # repeated_bytes[1] contained simple \ escaped non-UTF-8 raw binary data.
715  self.assertEqual(m.repeated_bytes[1], self._GOLDEN_BYTES_1)
716  # repeated_string[0] contained \ escaped data representing the UTF-8
717  # representation of _GOLDEN_STR_0 - it needs to decode as such.
718  self.assertEqual(m.repeated_string[0], self._GOLDEN_STR_0)
719 
720  def testParseBytes(self, message_module):
721  m = message_module.TestAllTypes()
722  text_format.Parse(self._BYTES_SAMPLE, m)
723  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
724  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
725  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
726  # repeated_bytes[1] contained simple \ escaped non-UTF-8 raw binary data.
727  self.assertEqual(m.repeated_bytes[1], self._GOLDEN_BYTES_1)
728  # repeated_string[0] contained \ escaped data representing the UTF-8
729  # representation of _GOLDEN_STR_0 - it needs to decode as such.
730  self.assertEqual(m.repeated_string[0], self._GOLDEN_STR_0)
731 
732  def testFromBytesFile(self, message_module):
733  m = message_module.TestAllTypes()
734  f = io.BytesIO(self._BYTES_SAMPLE)
735  text_format.ParseLines(f, m)
736  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
737  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
738  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
739 
740  def testFromUnicodeFile(self, message_module):
741  m = message_module.TestAllTypes()
742  f = io.StringIO(self._UNICODE_SAMPLE)
743  text_format.ParseLines(f, m)
744  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
745  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
746  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
747 
748  def testFromBytesLines(self, message_module):
749  m = message_module.TestAllTypes()
750  text_format.ParseLines(self._BYTES_SAMPLE.split(b'\n'), m)
751  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
752  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
753  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
754 
755  def testFromUnicodeLines(self, message_module):
756  m = message_module.TestAllTypes()
757  text_format.ParseLines(self._UNICODE_SAMPLE.split(u'\n'), m)
758  self.assertEqual(m.optional_bytes, self._GOLDEN_BYTES)
759  self.assertEqual(m.optional_string, self._GOLDEN_UNICODE)
760  self.assertEqual(m.repeated_bytes[0], self._GOLDEN_BYTES)
761 
762  def testParseDuplicateMessages(self, message_module):
763  message = message_module.TestAllTypes()
764  text = ('optional_nested_message { bb: 1 } '
765  'optional_nested_message { bb: 2 }')
766  six.assertRaisesRegex(self, text_format.ParseError, (
767  r'1:59 : Message type "\w+.TestAllTypes" '
768  r'should not have multiple "optional_nested_message" fields.'),
769  text_format.Parse, text,
770  message)
771 
772  def testParseDuplicateScalars(self, message_module):
773  message = message_module.TestAllTypes()
774  text = ('optional_int32: 42 ' 'optional_int32: 67')
775  six.assertRaisesRegex(self, text_format.ParseError, (
776  r'1:36 : Message type "\w+.TestAllTypes" should not '
777  r'have multiple "optional_int32" fields.'), text_format.Parse, text,
778  message)
779 
780 
781 @_parameterized.parameters(unittest_pb2, unittest_proto3_arena_pb2)
782 class TextFormatMergeTests(TextFormatBase):
783 
784  def testMergeDuplicateScalars(self, message_module):
785  message = message_module.TestAllTypes()
786  text = ('optional_int32: 42 ' 'optional_int32: 67')
787  r = text_format.Merge(text, message)
788  self.assertIs(r, message)
789  self.assertEqual(67, message.optional_int32)
790 
791  def testMergeDuplicateNestedMessageScalars(self, message_module):
792  message = message_module.TestAllTypes()
793  text = ('optional_nested_message { bb: 1 } '
794  'optional_nested_message { bb: 2 }')
795  r = text_format.Merge(text, message)
796  self.assertTrue(r is message)
797  self.assertEqual(2, message.optional_nested_message.bb)
798 
799  def testMergeMultipleOneof(self, message_module):
800  m_string = '\n'.join(['oneof_uint32: 11', 'oneof_string: "foo"'])
801  m2 = message_module.TestAllTypes()
802  text_format.Merge(m_string, m2)
803  self.assertEqual('oneof_string', m2.WhichOneof('oneof_field'))
804 
805 
806 # These are tests that aren't fundamentally specific to proto2, but are at
807 # the moment because of differences between the proto2 and proto3 test schemas.
808 # Ideally the schemas would be made more similar so these tests could pass.
809 class OnlyWorksWithProto2RightNowTests(TextFormatBase):
810 
811  def testPrintAllFieldsPointy(self):
812  message = unittest_pb2.TestAllTypes()
813  test_util.SetAllFields(message)
814  self.CompareToGoldenFile(
815  self.RemoveRedundantZeros(text_format.MessageToString(
816  message, pointy_brackets=True)),
817  'text_format_unittest_data_pointy_oneof.txt')
818 
819  def testParseGolden(self):
820  golden_text = '\n'.join(self.ReadGolden(
821  'text_format_unittest_data_oneof_implemented.txt'))
822  parsed_message = unittest_pb2.TestAllTypes()
823  r = text_format.Parse(golden_text, parsed_message)
824  self.assertIs(r, parsed_message)
825 
826  message = unittest_pb2.TestAllTypes()
827  test_util.SetAllFields(message)
828  self.assertEqual(message, parsed_message)
829 
830  def testPrintAllFields(self):
831  message = unittest_pb2.TestAllTypes()
832  test_util.SetAllFields(message)
833  self.CompareToGoldenFile(
834  self.RemoveRedundantZeros(text_format.MessageToString(message)),
835  'text_format_unittest_data_oneof_implemented.txt')
836 
837  def testPrintUnknownFields(self):
838  message = unittest_pb2.TestAllTypes()
839  message.optional_int32 = 101
840  message.optional_double = 102.0
841  message.optional_string = u'hello'
842  message.optional_bytes = b'103'
843  message.optionalgroup.a = 104
844  message.optional_nested_message.bb = 105
845  all_data = message.SerializeToString()
846  empty_message = unittest_pb2.TestEmptyMessage()
847  empty_message.ParseFromString(all_data)
848  self.assertEqual('1: 101\n'
849  '12: 4636878028842991616\n'
850  '14: "hello"\n'
851  '15: "103"\n'
852  '16 {\n'
853  ' 17: 104\n'
854  '}\n'
855  '18 {\n'
856  ' 1: 105\n'
857  '}\n',
858  text_format.MessageToString(empty_message,
859  print_unknown_fields=True))
860  self.assertEqual('1: 101 '
861  '12: 4636878028842991616 '
862  '14: "hello" '
863  '15: "103" '
864  '16 { 17: 104 } '
865  '18 { 1: 105 }',
866  text_format.MessageToString(empty_message,
867  print_unknown_fields=True,
868  as_one_line=True))
869 
870  def testPrintInIndexOrder(self):
871  message = unittest_pb2.TestFieldOrderings()
872  # Fields are listed in index order instead of field number.
873  message.my_string = 'str'
874  message.my_int = 101
875  message.my_float = 111
876  message.optional_nested_message.oo = 0
877  message.optional_nested_message.bb = 1
878  message.Extensions[unittest_pb2.my_extension_string] = 'ext_str0'
879  # Extensions are listed based on the order of extension number.
880  # Extension number 12.
881  message.Extensions[unittest_pb2.TestExtensionOrderings2.
882  test_ext_orderings2].my_string = 'ext_str2'
883  # Extension number 13.
884  message.Extensions[unittest_pb2.TestExtensionOrderings1.
885  test_ext_orderings1].my_string = 'ext_str1'
886  # Extension number 14.
887  message.Extensions[
888  unittest_pb2.TestExtensionOrderings2.TestExtensionOrderings3.
889  test_ext_orderings3].my_string = 'ext_str3'
890 
891  # Print in index order.
892  self.CompareToGoldenText(
893  self.RemoveRedundantZeros(
894  text_format.MessageToString(message, use_index_order=True)),
895  'my_string: "str"\n'
896  'my_int: 101\n'
897  'my_float: 111\n'
898  'optional_nested_message {\n'
899  ' oo: 0\n'
900  ' bb: 1\n'
901  '}\n'
902  '[protobuf_unittest.TestExtensionOrderings2.test_ext_orderings2] {\n'
903  ' my_string: "ext_str2"\n'
904  '}\n'
905  '[protobuf_unittest.TestExtensionOrderings1.test_ext_orderings1] {\n'
906  ' my_string: "ext_str1"\n'
907  '}\n'
908  '[protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3'
909  '.test_ext_orderings3] {\n'
910  ' my_string: "ext_str3"\n'
911  '}\n'
912  '[protobuf_unittest.my_extension_string]: "ext_str0"\n')
913  # By default, print in field number order.
914  self.CompareToGoldenText(
915  self.RemoveRedundantZeros(text_format.MessageToString(message)),
916  'my_int: 101\n'
917  'my_string: "str"\n'
918  '[protobuf_unittest.TestExtensionOrderings2.test_ext_orderings2] {\n'
919  ' my_string: "ext_str2"\n'
920  '}\n'
921  '[protobuf_unittest.TestExtensionOrderings1.test_ext_orderings1] {\n'
922  ' my_string: "ext_str1"\n'
923  '}\n'
924  '[protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3'
925  '.test_ext_orderings3] {\n'
926  ' my_string: "ext_str3"\n'
927  '}\n'
928  '[protobuf_unittest.my_extension_string]: "ext_str0"\n'
929  'my_float: 111\n'
930  'optional_nested_message {\n'
931  ' bb: 1\n'
932  ' oo: 0\n'
933  '}\n')
934 
935  def testMergeLinesGolden(self):
936  opened = self.ReadGolden('text_format_unittest_data_oneof_implemented.txt')
937  parsed_message = unittest_pb2.TestAllTypes()
938  r = text_format.MergeLines(opened, parsed_message)
939  self.assertIs(r, parsed_message)
940 
941  message = unittest_pb2.TestAllTypes()
942  test_util.SetAllFields(message)
943  self.assertEqual(message, parsed_message)
944 
945  def testParseLinesGolden(self):
946  opened = self.ReadGolden('text_format_unittest_data_oneof_implemented.txt')
947  parsed_message = unittest_pb2.TestAllTypes()
948  r = text_format.ParseLines(opened, parsed_message)
949  self.assertIs(r, parsed_message)
950 
951  message = unittest_pb2.TestAllTypes()
952  test_util.SetAllFields(message)
953  self.assertEqual(message, parsed_message)
954 
955  def testPrintMap(self):
956  message = map_unittest_pb2.TestMap()
957 
958  message.map_int32_int32[-123] = -456
959  message.map_int64_int64[-2**33] = -2**34
960  message.map_uint32_uint32[123] = 456
961  message.map_uint64_uint64[2**33] = 2**34
962  message.map_string_string['abc'] = '123'
963  message.map_int32_foreign_message[111].c = 5
964 
965  # Maps are serialized to text format using their underlying repeated
966  # representation.
967  self.CompareToGoldenText(
968  text_format.MessageToString(message), 'map_int32_int32 {\n'
969  ' key: -123\n'
970  ' value: -456\n'
971  '}\n'
972  'map_int64_int64 {\n'
973  ' key: -8589934592\n'
974  ' value: -17179869184\n'
975  '}\n'
976  'map_uint32_uint32 {\n'
977  ' key: 123\n'
978  ' value: 456\n'
979  '}\n'
980  'map_uint64_uint64 {\n'
981  ' key: 8589934592\n'
982  ' value: 17179869184\n'
983  '}\n'
984  'map_string_string {\n'
985  ' key: "abc"\n'
986  ' value: "123"\n'
987  '}\n'
988  'map_int32_foreign_message {\n'
989  ' key: 111\n'
990  ' value {\n'
991  ' c: 5\n'
992  ' }\n'
993  '}\n')
994 
995  # In cpp implementation, __str__ calls the cpp implementation of text format.
996  def testPrintMapUsingCppImplementation(self):
997  message = map_unittest_pb2.TestMap()
998  inner_msg = message.map_int32_foreign_message[111]
999  inner_msg.c = 1
1000  self.assertEqual(
1001  str(message),
1002  'map_int32_foreign_message {\n'
1003  ' key: 111\n'
1004  ' value {\n'
1005  ' c: 1\n'
1006  ' }\n'
1007  '}\n')
1008  inner_msg.c = 2
1009  self.assertEqual(
1010  str(message),
1011  'map_int32_foreign_message {\n'
1012  ' key: 111\n'
1013  ' value {\n'
1014  ' c: 2\n'
1015  ' }\n'
1016  '}\n')
1017 
1018  def testMapOrderEnforcement(self):
1019  message = map_unittest_pb2.TestMap()
1020  for letter in string.ascii_uppercase[13:26]:
1021  message.map_string_string[letter] = 'dummy'
1022  for letter in reversed(string.ascii_uppercase[0:13]):
1023  message.map_string_string[letter] = 'dummy'
1024  golden = ''.join(('map_string_string {\n key: "%c"\n value: "dummy"\n}\n'
1025  % (letter,) for letter in string.ascii_uppercase))
1026  self.CompareToGoldenText(text_format.MessageToString(message), golden)
1027 
1028  # TODO(teboring): In c/137553523, not serializing default value for map entry
1029  # message has been fixed. This test needs to be disabled in order to submit
1030  # that cl. Add this back when c/137553523 has been submitted.
1031  # def testMapOrderSemantics(self):
1032  # golden_lines = self.ReadGolden('map_test_data.txt')
1033 
1034  # message = map_unittest_pb2.TestMap()
1035  # text_format.ParseLines(golden_lines, message)
1036  # candidate = text_format.MessageToString(message)
1037  # # The Python implementation emits "1.0" for the double value that the C++
1038  # # implementation emits as "1".
1039  # candidate = candidate.replace('1.0', '1', 2)
1040  # candidate = candidate.replace('0.0', '0', 2)
1041  # self.assertMultiLineEqual(candidate, ''.join(golden_lines))
1042 
1043 
1044 # Tests of proto2-only features (MessageSet, extensions, etc.).
1045 class Proto2Tests(TextFormatBase):
1046 
1047  def testPrintMessageSet(self):
1048  message = unittest_mset_pb2.TestMessageSetContainer()
1049  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1050  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1051  message.message_set.Extensions[ext1].i = 23
1052  message.message_set.Extensions[ext2].str = 'foo'
1053  self.CompareToGoldenText(
1054  text_format.MessageToString(message), 'message_set {\n'
1055  ' [protobuf_unittest.TestMessageSetExtension1] {\n'
1056  ' i: 23\n'
1057  ' }\n'
1058  ' [protobuf_unittest.TestMessageSetExtension2] {\n'
1059  ' str: \"foo\"\n'
1060  ' }\n'
1061  '}\n')
1062 
1063  message = message_set_extensions_pb2.TestMessageSet()
1064  ext = message_set_extensions_pb2.message_set_extension3
1065  message.Extensions[ext].text = 'bar'
1066  self.CompareToGoldenText(
1067  text_format.MessageToString(message),
1068  '[google.protobuf.internal.TestMessageSetExtension3] {\n'
1069  ' text: \"bar\"\n'
1070  '}\n')
1071 
1072  def testPrintMessageSetByFieldNumber(self):
1073  out = text_format.TextWriter(False)
1074  message = unittest_mset_pb2.TestMessageSetContainer()
1075  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1076  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1077  message.message_set.Extensions[ext1].i = 23
1078  message.message_set.Extensions[ext2].str = 'foo'
1079  text_format.PrintMessage(message, out, use_field_number=True)
1080  self.CompareToGoldenText(out.getvalue(), '1 {\n'
1081  ' 1545008 {\n'
1082  ' 15: 23\n'
1083  ' }\n'
1084  ' 1547769 {\n'
1085  ' 25: \"foo\"\n'
1086  ' }\n'
1087  '}\n')
1088  out.close()
1089 
1090  def testPrintMessageSetAsOneLine(self):
1091  message = unittest_mset_pb2.TestMessageSetContainer()
1092  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1093  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1094  message.message_set.Extensions[ext1].i = 23
1095  message.message_set.Extensions[ext2].str = 'foo'
1096  self.CompareToGoldenText(
1097  text_format.MessageToString(message, as_one_line=True),
1098  'message_set {'
1099  ' [protobuf_unittest.TestMessageSetExtension1] {'
1100  ' i: 23'
1101  ' }'
1102  ' [protobuf_unittest.TestMessageSetExtension2] {'
1103  ' str: \"foo\"'
1104  ' }'
1105  ' }')
1106 
1107  def testParseMessageSet(self):
1108  message = unittest_pb2.TestAllTypes()
1109  text = ('repeated_uint64: 1\n' 'repeated_uint64: 2\n')
1110  text_format.Parse(text, message)
1111  self.assertEqual(1, message.repeated_uint64[0])
1112  self.assertEqual(2, message.repeated_uint64[1])
1113 
1114  message = unittest_mset_pb2.TestMessageSetContainer()
1115  text = ('message_set {\n'
1116  ' [protobuf_unittest.TestMessageSetExtension1] {\n'
1117  ' i: 23\n'
1118  ' }\n'
1119  ' [protobuf_unittest.TestMessageSetExtension2] {\n'
1120  ' str: \"foo\"\n'
1121  ' }\n'
1122  '}\n')
1123  text_format.Parse(text, message)
1124  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1125  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1126  self.assertEqual(23, message.message_set.Extensions[ext1].i)
1127  self.assertEqual('foo', message.message_set.Extensions[ext2].str)
1128 
1129  def testExtensionInsideAnyMessage(self):
1130  message = test_extend_any.TestAny()
1131  text = ('value {\n'
1132  ' [type.googleapis.com/google.protobuf.internal.TestAny] {\n'
1133  ' [google.protobuf.internal.TestAnyExtension1.extension1] {\n'
1134  ' i: 10\n'
1135  ' }\n'
1136  ' }\n'
1137  '}\n')
1138  text_format.Merge(text, message, descriptor_pool=descriptor_pool.Default())
1139  self.CompareToGoldenText(
1140  text_format.MessageToString(
1141  message, descriptor_pool=descriptor_pool.Default()),
1142  text)
1143 
1144  def testParseMessageByFieldNumber(self):
1145  message = unittest_pb2.TestAllTypes()
1146  text = ('34: 1\n' 'repeated_uint64: 2\n')
1147  text_format.Parse(text, message, allow_field_number=True)
1148  self.assertEqual(1, message.repeated_uint64[0])
1149  self.assertEqual(2, message.repeated_uint64[1])
1150 
1151  message = unittest_mset_pb2.TestMessageSetContainer()
1152  text = ('1 {\n'
1153  ' 1545008 {\n'
1154  ' 15: 23\n'
1155  ' }\n'
1156  ' 1547769 {\n'
1157  ' 25: \"foo\"\n'
1158  ' }\n'
1159  '}\n')
1160  text_format.Parse(text, message, allow_field_number=True)
1161  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1162  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1163  self.assertEqual(23, message.message_set.Extensions[ext1].i)
1164  self.assertEqual('foo', message.message_set.Extensions[ext2].str)
1165 
1166  # Can't parse field number without set allow_field_number=True.
1167  message = unittest_pb2.TestAllTypes()
1168  text = '34:1\n'
1169  six.assertRaisesRegex(self, text_format.ParseError, (
1170  r'1:1 : Message type "\w+.TestAllTypes" has no field named '
1171  r'"34".'), text_format.Parse, text, message)
1172 
1173  # Can't parse if field number is not found.
1174  text = '1234:1\n'
1175  six.assertRaisesRegex(
1176  self,
1177  text_format.ParseError,
1178  (r'1:1 : Message type "\w+.TestAllTypes" has no field named '
1179  r'"1234".'),
1180  text_format.Parse,
1181  text,
1182  message,
1183  allow_field_number=True)
1184 
1185  def testPrintAllExtensions(self):
1186  message = unittest_pb2.TestAllExtensions()
1187  test_util.SetAllExtensions(message)
1188  self.CompareToGoldenFile(
1189  self.RemoveRedundantZeros(text_format.MessageToString(message)),
1190  'text_format_unittest_extensions_data.txt')
1191 
1192  def testPrintAllExtensionsPointy(self):
1193  message = unittest_pb2.TestAllExtensions()
1194  test_util.SetAllExtensions(message)
1195  self.CompareToGoldenFile(
1196  self.RemoveRedundantZeros(text_format.MessageToString(
1197  message, pointy_brackets=True)),
1198  'text_format_unittest_extensions_data_pointy.txt')
1199 
1200  def testParseGoldenExtensions(self):
1201  golden_text = '\n'.join(self.ReadGolden(
1202  'text_format_unittest_extensions_data.txt'))
1203  parsed_message = unittest_pb2.TestAllExtensions()
1204  text_format.Parse(golden_text, parsed_message)
1205 
1206  message = unittest_pb2.TestAllExtensions()
1207  test_util.SetAllExtensions(message)
1208  self.assertEqual(message, parsed_message)
1209 
1210  def testParseAllExtensions(self):
1211  message = unittest_pb2.TestAllExtensions()
1212  test_util.SetAllExtensions(message)
1213  ascii_text = text_format.MessageToString(message)
1214 
1215  parsed_message = unittest_pb2.TestAllExtensions()
1216  text_format.Parse(ascii_text, parsed_message)
1217  self.assertEqual(message, parsed_message)
1218 
1219  def testParseAllowedUnknownExtension(self):
1220  # Skip over unknown extension correctly.
1221  message = unittest_mset_pb2.TestMessageSetContainer()
1222  text = ('message_set {\n'
1223  ' [unknown_extension] {\n'
1224  ' i: 23\n'
1225  ' bin: "\xe0"'
1226  ' [nested_unknown_ext]: {\n'
1227  ' i: 23\n'
1228  ' x: x\n'
1229  ' test: "test_string"\n'
1230  ' floaty_float: -0.315\n'
1231  ' num: -inf\n'
1232  ' multiline_str: "abc"\n'
1233  ' "def"\n'
1234  ' "xyz."\n'
1235  ' [nested_unknown_ext.ext]: <\n'
1236  ' i: 23\n'
1237  ' i: 24\n'
1238  ' pointfloat: .3\n'
1239  ' test: "test_string"\n'
1240  ' floaty_float: -0.315\n'
1241  ' num: -inf\n'
1242  ' long_string: "test" "test2" \n'
1243  ' >\n'
1244  ' }\n'
1245  ' }\n'
1246  ' [unknown_extension]: 5\n'
1247  ' [unknown_extension_with_number_field] {\n'
1248  ' 1: "some_field"\n'
1249  ' 2: -0.451\n'
1250  ' }\n'
1251  '}\n')
1252  text_format.Parse(text, message, allow_unknown_extension=True)
1253  golden = 'message_set {\n}\n'
1254  self.CompareToGoldenText(text_format.MessageToString(message), golden)
1255 
1256  # Catch parse errors in unknown extension.
1257  message = unittest_mset_pb2.TestMessageSetContainer()
1258  malformed = ('message_set {\n'
1259  ' [unknown_extension] {\n'
1260  ' i:\n' # Missing value.
1261  ' }\n'
1262  '}\n')
1263  six.assertRaisesRegex(self,
1264  text_format.ParseError,
1265  'Invalid field value: }',
1266  text_format.Parse,
1267  malformed,
1268  message,
1269  allow_unknown_extension=True)
1270 
1271  message = unittest_mset_pb2.TestMessageSetContainer()
1272  malformed = ('message_set {\n'
1273  ' [unknown_extension] {\n'
1274  ' str: "malformed string\n' # Missing closing quote.
1275  ' }\n'
1276  '}\n')
1277  six.assertRaisesRegex(self,
1278  text_format.ParseError,
1279  'Invalid field value: "',
1280  text_format.Parse,
1281  malformed,
1282  message,
1283  allow_unknown_extension=True)
1284 
1285  message = unittest_mset_pb2.TestMessageSetContainer()
1286  malformed = ('message_set {\n'
1287  ' [unknown_extension] {\n'
1288  ' str: "malformed\n multiline\n string\n'
1289  ' }\n'
1290  '}\n')
1291  six.assertRaisesRegex(self,
1292  text_format.ParseError,
1293  'Invalid field value: "',
1294  text_format.Parse,
1295  malformed,
1296  message,
1297  allow_unknown_extension=True)
1298 
1299  message = unittest_mset_pb2.TestMessageSetContainer()
1300  malformed = ('message_set {\n'
1301  ' [malformed_extension] <\n'
1302  ' i: -5\n'
1303  ' \n' # Missing '>' here.
1304  '}\n')
1305  six.assertRaisesRegex(self,
1306  text_format.ParseError,
1307  '5:1 : \'}\': Expected ">".',
1308  text_format.Parse,
1309  malformed,
1310  message,
1311  allow_unknown_extension=True)
1312 
1313  # Don't allow unknown fields with allow_unknown_extension=True.
1314  message = unittest_mset_pb2.TestMessageSetContainer()
1315  malformed = ('message_set {\n'
1316  ' unknown_field: true\n'
1317  '}\n')
1318  six.assertRaisesRegex(self,
1319  text_format.ParseError,
1320  ('2:3 : Message type '
1321  '"proto2_wireformat_unittest.TestMessageSet" has no'
1322  ' field named "unknown_field".'),
1323  text_format.Parse,
1324  malformed,
1325  message,
1326  allow_unknown_extension=True)
1327 
1328  # Parse known extension correctly.
1329  message = unittest_mset_pb2.TestMessageSetContainer()
1330  text = ('message_set {\n'
1331  ' [protobuf_unittest.TestMessageSetExtension1] {\n'
1332  ' i: 23\n'
1333  ' }\n'
1334  ' [protobuf_unittest.TestMessageSetExtension2] {\n'
1335  ' str: \"foo\"\n'
1336  ' }\n'
1337  '}\n')
1338  text_format.Parse(text, message, allow_unknown_extension=True)
1339  ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
1340  ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
1341  self.assertEqual(23, message.message_set.Extensions[ext1].i)
1342  self.assertEqual('foo', message.message_set.Extensions[ext2].str)
1343 
1344  def testParseBadIdentifier(self):
1345  message = unittest_pb2.TestAllTypes()
1346  text = ('optional_nested_message { "bb": 1 }')
1347  with self.assertRaises(text_format.ParseError) as e:
1348  text_format.Parse(text, message)
1349  self.assertEqual(str(e.exception),
1350  '1:27 : \'optional_nested_message { "bb": 1 }\': '
1351  'Expected identifier or number, got "bb".')
1352 
1353  def testParseBadExtension(self):
1354  message = unittest_pb2.TestAllExtensions()
1355  text = '[unknown_extension]: 8\n'
1356  six.assertRaisesRegex(self, text_format.ParseError,
1357  '1:2 : Extension "unknown_extension" not registered.',
1358  text_format.Parse, text, message)
1359  message = unittest_pb2.TestAllTypes()
1360  six.assertRaisesRegex(self, text_format.ParseError, (
1361  '1:2 : Message type "protobuf_unittest.TestAllTypes" does not have '
1362  'extensions.'), text_format.Parse, text, message)
1363 
1364  def testParseNumericUnknownEnum(self):
1365  message = unittest_pb2.TestAllTypes()
1366  text = 'optional_nested_enum: 100'
1367  six.assertRaisesRegex(self, text_format.ParseError,
1368  (r'1:23 : \'optional_nested_enum: 100\': '
1369  r'Enum type "\w+.TestAllTypes.NestedEnum" '
1370  r'has no value with number 100.'), text_format.Parse,
1371  text, message)
1372 
1373  def testMergeDuplicateExtensionScalars(self):
1374  message = unittest_pb2.TestAllExtensions()
1375  text = ('[protobuf_unittest.optional_int32_extension]: 42 '
1376  '[protobuf_unittest.optional_int32_extension]: 67')
1377  text_format.Merge(text, message)
1378  self.assertEqual(67,
1379  message.Extensions[unittest_pb2.optional_int32_extension])
1380 
1381  def testParseDuplicateExtensionScalars(self):
1382  message = unittest_pb2.TestAllExtensions()
1383  text = ('[protobuf_unittest.optional_int32_extension]: 42 '
1384  '[protobuf_unittest.optional_int32_extension]: 67')
1385  six.assertRaisesRegex(self, text_format.ParseError, (
1386  '1:96 : Message type "protobuf_unittest.TestAllExtensions" '
1387  'should not have multiple '
1388  '"protobuf_unittest.optional_int32_extension" extensions.'),
1389  text_format.Parse, text, message)
1390 
1391  def testParseDuplicateExtensionMessages(self):
1392  message = unittest_pb2.TestAllExtensions()
1393  text = ('[protobuf_unittest.optional_nested_message_extension]: {} '
1394  '[protobuf_unittest.optional_nested_message_extension]: {}')
1395  six.assertRaisesRegex(self, text_format.ParseError, (
1396  '1:114 : Message type "protobuf_unittest.TestAllExtensions" '
1397  'should not have multiple '
1398  '"protobuf_unittest.optional_nested_message_extension" extensions.'),
1399  text_format.Parse, text, message)
1400 
1401  def testParseGroupNotClosed(self):
1402  message = unittest_pb2.TestAllTypes()
1403  text = 'RepeatedGroup: <'
1404  six.assertRaisesRegex(self, text_format.ParseError, '1:16 : Expected ">".',
1405  text_format.Parse, text, message)
1406  text = 'RepeatedGroup: {'
1407  six.assertRaisesRegex(self, text_format.ParseError, '1:16 : Expected "}".',
1408  text_format.Parse, text, message)
1409 
1410  def testParseEmptyGroup(self):
1411  message = unittest_pb2.TestAllTypes()
1412  text = 'OptionalGroup: {}'
1413  text_format.Parse(text, message)
1414  self.assertTrue(message.HasField('optionalgroup'))
1415 
1416  message.Clear()
1417 
1418  message = unittest_pb2.TestAllTypes()
1419  text = 'OptionalGroup: <>'
1420  text_format.Parse(text, message)
1421  self.assertTrue(message.HasField('optionalgroup'))
1422 
1423  # Maps aren't really proto2-only, but our test schema only has maps for
1424  # proto2.
1425  def testParseMap(self):
1426  text = ('map_int32_int32 {\n'
1427  ' key: -123\n'
1428  ' value: -456\n'
1429  '}\n'
1430  'map_int64_int64 {\n'
1431  ' key: -8589934592\n'
1432  ' value: -17179869184\n'
1433  '}\n'
1434  'map_uint32_uint32 {\n'
1435  ' key: 123\n'
1436  ' value: 456\n'
1437  '}\n'
1438  'map_uint64_uint64 {\n'
1439  ' key: 8589934592\n'
1440  ' value: 17179869184\n'
1441  '}\n'
1442  'map_string_string {\n'
1443  ' key: "abc"\n'
1444  ' value: "123"\n'
1445  '}\n'
1446  'map_int32_foreign_message {\n'
1447  ' key: 111\n'
1448  ' value {\n'
1449  ' c: 5\n'
1450  ' }\n'
1451  '}\n')
1452  message = map_unittest_pb2.TestMap()
1453  text_format.Parse(text, message)
1454 
1455  self.assertEqual(-456, message.map_int32_int32[-123])
1456  self.assertEqual(-2**34, message.map_int64_int64[-2**33])
1457  self.assertEqual(456, message.map_uint32_uint32[123])
1458  self.assertEqual(2**34, message.map_uint64_uint64[2**33])
1459  self.assertEqual('123', message.map_string_string['abc'])
1460  self.assertEqual(5, message.map_int32_foreign_message[111].c)
1461 
1462 
1463 class Proto3Tests(unittest.TestCase):
1464 
1465  def testPrintMessageExpandAny(self):
1466  packed_message = unittest_pb2.OneString()
1467  packed_message.data = 'string'
1468  message = any_test_pb2.TestAny()
1469  message.any_value.Pack(packed_message)
1470  self.assertEqual(
1471  text_format.MessageToString(message,
1472  descriptor_pool=descriptor_pool.Default()),
1473  'any_value {\n'
1474  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1475  ' data: "string"\n'
1476  ' }\n'
1477  '}\n')
1478 
1479  def testTopAnyMessage(self):
1480  packed_msg = unittest_pb2.OneString()
1481  msg = any_pb2.Any()
1482  msg.Pack(packed_msg)
1483  text = text_format.MessageToString(msg)
1484  other_msg = text_format.Parse(text, any_pb2.Any())
1485  self.assertEqual(msg, other_msg)
1486 
1487  def testPrintMessageExpandAnyRepeated(self):
1488  packed_message = unittest_pb2.OneString()
1489  message = any_test_pb2.TestAny()
1490  packed_message.data = 'string0'
1491  message.repeated_any_value.add().Pack(packed_message)
1492  packed_message.data = 'string1'
1493  message.repeated_any_value.add().Pack(packed_message)
1494  self.assertEqual(
1495  text_format.MessageToString(message),
1496  'repeated_any_value {\n'
1497  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1498  ' data: "string0"\n'
1499  ' }\n'
1500  '}\n'
1501  'repeated_any_value {\n'
1502  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1503  ' data: "string1"\n'
1504  ' }\n'
1505  '}\n')
1506 
1507  def testPrintMessageExpandAnyDescriptorPoolMissingType(self):
1508  packed_message = unittest_pb2.OneString()
1509  packed_message.data = 'string'
1510  message = any_test_pb2.TestAny()
1511  message.any_value.Pack(packed_message)
1512  empty_pool = descriptor_pool.DescriptorPool()
1513  self.assertEqual(
1514  text_format.MessageToString(message, descriptor_pool=empty_pool),
1515  'any_value {\n'
1516  ' type_url: "type.googleapis.com/protobuf_unittest.OneString"\n'
1517  ' value: "\\n\\006string"\n'
1518  '}\n')
1519 
1520  def testPrintMessageExpandAnyPointyBrackets(self):
1521  packed_message = unittest_pb2.OneString()
1522  packed_message.data = 'string'
1523  message = any_test_pb2.TestAny()
1524  message.any_value.Pack(packed_message)
1525  self.assertEqual(
1526  text_format.MessageToString(message,
1527  pointy_brackets=True),
1528  'any_value <\n'
1529  ' [type.googleapis.com/protobuf_unittest.OneString] <\n'
1530  ' data: "string"\n'
1531  ' >\n'
1532  '>\n')
1533 
1534  def testPrintMessageExpandAnyAsOneLine(self):
1535  packed_message = unittest_pb2.OneString()
1536  packed_message.data = 'string'
1537  message = any_test_pb2.TestAny()
1538  message.any_value.Pack(packed_message)
1539  self.assertEqual(
1540  text_format.MessageToString(message,
1541  as_one_line=True),
1542  'any_value {'
1543  ' [type.googleapis.com/protobuf_unittest.OneString]'
1544  ' { data: "string" } '
1545  '}')
1546 
1547  def testPrintMessageExpandAnyAsOneLinePointyBrackets(self):
1548  packed_message = unittest_pb2.OneString()
1549  packed_message.data = 'string'
1550  message = any_test_pb2.TestAny()
1551  message.any_value.Pack(packed_message)
1552  self.assertEqual(
1553  text_format.MessageToString(message,
1554  as_one_line=True,
1555  pointy_brackets=True,
1556  descriptor_pool=descriptor_pool.Default()),
1557  'any_value <'
1558  ' [type.googleapis.com/protobuf_unittest.OneString]'
1559  ' < data: "string" > '
1560  '>')
1561 
1562  def testPrintAndParseMessageInvalidAny(self):
1563  packed_message = unittest_pb2.OneString()
1564  packed_message.data = 'string'
1565  message = any_test_pb2.TestAny()
1566  message.any_value.Pack(packed_message)
1567  # Only include string after last '/' in type_url.
1568  message.any_value.type_url = message.any_value.TypeName()
1569  text = text_format.MessageToString(message)
1570  self.assertEqual(
1571  text, 'any_value {\n'
1572  ' type_url: "protobuf_unittest.OneString"\n'
1573  ' value: "\\n\\006string"\n'
1574  '}\n')
1575 
1576  parsed_message = any_test_pb2.TestAny()
1577  text_format.Parse(text, parsed_message)
1578  self.assertEqual(message, parsed_message)
1579 
1580  def testUnknownEnums(self):
1581  message = unittest_proto3_arena_pb2.TestAllTypes()
1582  message2 = unittest_proto3_arena_pb2.TestAllTypes()
1583  message.optional_nested_enum = 999
1584  text_string = text_format.MessageToString(message)
1585  text_format.Parse(text_string, message2)
1586  self.assertEqual(999, message2.optional_nested_enum)
1587 
1588  def testMergeExpandedAny(self):
1589  message = any_test_pb2.TestAny()
1590  text = ('any_value {\n'
1591  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1592  ' data: "string"\n'
1593  ' }\n'
1594  '}\n')
1595  text_format.Merge(text, message)
1596  packed_message = unittest_pb2.OneString()
1597  message.any_value.Unpack(packed_message)
1598  self.assertEqual('string', packed_message.data)
1599  message.Clear()
1600  text_format.Parse(text, message)
1601  packed_message = unittest_pb2.OneString()
1602  message.any_value.Unpack(packed_message)
1603  self.assertEqual('string', packed_message.data)
1604 
1605  def testMergeExpandedAnyRepeated(self):
1606  message = any_test_pb2.TestAny()
1607  text = ('repeated_any_value {\n'
1608  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1609  ' data: "string0"\n'
1610  ' }\n'
1611  '}\n'
1612  'repeated_any_value {\n'
1613  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1614  ' data: "string1"\n'
1615  ' }\n'
1616  '}\n')
1617  text_format.Merge(text, message)
1618  packed_message = unittest_pb2.OneString()
1619  message.repeated_any_value[0].Unpack(packed_message)
1620  self.assertEqual('string0', packed_message.data)
1621  message.repeated_any_value[1].Unpack(packed_message)
1622  self.assertEqual('string1', packed_message.data)
1623 
1624  def testMergeExpandedAnyPointyBrackets(self):
1625  message = any_test_pb2.TestAny()
1626  text = ('any_value {\n'
1627  ' [type.googleapis.com/protobuf_unittest.OneString] <\n'
1628  ' data: "string"\n'
1629  ' >\n'
1630  '}\n')
1631  text_format.Merge(text, message)
1632  packed_message = unittest_pb2.OneString()
1633  message.any_value.Unpack(packed_message)
1634  self.assertEqual('string', packed_message.data)
1635 
1636  def testMergeAlternativeUrl(self):
1637  message = any_test_pb2.TestAny()
1638  text = ('any_value {\n'
1639  ' [type.otherapi.com/protobuf_unittest.OneString] {\n'
1640  ' data: "string"\n'
1641  ' }\n'
1642  '}\n')
1643  text_format.Merge(text, message)
1644  packed_message = unittest_pb2.OneString()
1645  self.assertEqual('type.otherapi.com/protobuf_unittest.OneString',
1646  message.any_value.type_url)
1647 
1648  def testMergeExpandedAnyDescriptorPoolMissingType(self):
1649  message = any_test_pb2.TestAny()
1650  text = ('any_value {\n'
1651  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1652  ' data: "string"\n'
1653  ' }\n'
1654  '}\n')
1655  with self.assertRaises(text_format.ParseError) as e:
1656  empty_pool = descriptor_pool.DescriptorPool()
1657  text_format.Merge(text, message, descriptor_pool=empty_pool)
1658  self.assertEqual(
1659  str(e.exception),
1660  'Type protobuf_unittest.OneString not found in descriptor pool')
1661 
1662  def testMergeUnexpandedAny(self):
1663  text = ('any_value {\n'
1664  ' type_url: "type.googleapis.com/protobuf_unittest.OneString"\n'
1665  ' value: "\\n\\006string"\n'
1666  '}\n')
1667  message = any_test_pb2.TestAny()
1668  text_format.Merge(text, message)
1669  packed_message = unittest_pb2.OneString()
1670  message.any_value.Unpack(packed_message)
1671  self.assertEqual('string', packed_message.data)
1672 
1673  def testMergeMissingAnyEndToken(self):
1674  message = any_test_pb2.TestAny()
1675  text = ('any_value {\n'
1676  ' [type.googleapis.com/protobuf_unittest.OneString] {\n'
1677  ' data: "string"\n')
1678  with self.assertRaises(text_format.ParseError) as e:
1679  text_format.Merge(text, message)
1680  self.assertEqual(str(e.exception), '3:11 : Expected "}".')
1681 
1682 
1683 class TokenizerTest(unittest.TestCase):
1684 
1685  def testSimpleTokenCases(self):
1686  text = ('identifier1:"string1"\n \n\n'
1687  'identifier2 : \n \n123 \n identifier3 :\'string\'\n'
1688  'identifiER_4 : 1.1e+2 ID5:-0.23 ID6:\'aaaa\\\'bbbb\'\n'
1689  'ID7 : "aa\\"bb"\n\n\n\n ID8: {A:inf B:-inf C:true D:false}\n'
1690  'ID9: 22 ID10: -111111111111111111 ID11: -22\n'
1691  'ID12: 2222222222222222222 ID13: 1.23456f ID14: 1.2e+2f '
1692  'false_bool: 0 true_BOOL:t \n true_bool1: 1 false_BOOL1:f '
1693  'False_bool: False True_bool: True X:iNf Y:-inF Z:nAN')
1694  tokenizer = text_format.Tokenizer(text.splitlines())
1695  methods = [(tokenizer.ConsumeIdentifier, 'identifier1'), ':',
1696  (tokenizer.ConsumeString, 'string1'),
1697  (tokenizer.ConsumeIdentifier, 'identifier2'), ':',
1698  (tokenizer.ConsumeInteger, 123),
1699  (tokenizer.ConsumeIdentifier, 'identifier3'), ':',
1700  (tokenizer.ConsumeString, 'string'),
1701  (tokenizer.ConsumeIdentifier, 'identifiER_4'), ':',
1702  (tokenizer.ConsumeFloat, 1.1e+2),
1703  (tokenizer.ConsumeIdentifier, 'ID5'), ':',
1704  (tokenizer.ConsumeFloat, -0.23),
1705  (tokenizer.ConsumeIdentifier, 'ID6'), ':',
1706  (tokenizer.ConsumeString, 'aaaa\'bbbb'),
1707  (tokenizer.ConsumeIdentifier, 'ID7'), ':',
1708  (tokenizer.ConsumeString, 'aa\"bb'),
1709  (tokenizer.ConsumeIdentifier, 'ID8'), ':', '{',
1710  (tokenizer.ConsumeIdentifier, 'A'), ':',
1711  (tokenizer.ConsumeFloat, float('inf')),
1712  (tokenizer.ConsumeIdentifier, 'B'), ':',
1713  (tokenizer.ConsumeFloat, -float('inf')),
1714  (tokenizer.ConsumeIdentifier, 'C'), ':',
1715  (tokenizer.ConsumeBool, True),
1716  (tokenizer.ConsumeIdentifier, 'D'), ':',
1717  (tokenizer.ConsumeBool, False), '}',
1718  (tokenizer.ConsumeIdentifier, 'ID9'), ':',
1719  (tokenizer.ConsumeInteger, 22),
1720  (tokenizer.ConsumeIdentifier, 'ID10'), ':',
1721  (tokenizer.ConsumeInteger, -111111111111111111),
1722  (tokenizer.ConsumeIdentifier, 'ID11'), ':',
1723  (tokenizer.ConsumeInteger, -22),
1724  (tokenizer.ConsumeIdentifier, 'ID12'), ':',
1725  (tokenizer.ConsumeInteger, 2222222222222222222),
1726  (tokenizer.ConsumeIdentifier, 'ID13'), ':',
1727  (tokenizer.ConsumeFloat, 1.23456),
1728  (tokenizer.ConsumeIdentifier, 'ID14'), ':',
1729  (tokenizer.ConsumeFloat, 1.2e+2),
1730  (tokenizer.ConsumeIdentifier, 'false_bool'), ':',
1731  (tokenizer.ConsumeBool, False),
1732  (tokenizer.ConsumeIdentifier, 'true_BOOL'), ':',
1733  (tokenizer.ConsumeBool, True),
1734  (tokenizer.ConsumeIdentifier, 'true_bool1'), ':',
1735  (tokenizer.ConsumeBool, True),
1736  (tokenizer.ConsumeIdentifier, 'false_BOOL1'), ':',
1737  (tokenizer.ConsumeBool, False),
1738  (tokenizer.ConsumeIdentifier, 'False_bool'), ':',
1739  (tokenizer.ConsumeBool, False),
1740  (tokenizer.ConsumeIdentifier, 'True_bool'), ':',
1741  (tokenizer.ConsumeBool, True),
1742  (tokenizer.ConsumeIdentifier, 'X'), ':',
1743  (tokenizer.ConsumeFloat, float('inf')),
1744  (tokenizer.ConsumeIdentifier, 'Y'), ':',
1745  (tokenizer.ConsumeFloat, float('-inf')),
1746  (tokenizer.ConsumeIdentifier, 'Z'), ':',
1747  (tokenizer.ConsumeFloat, float('nan'))]
1748 
1749  i = 0
1750  while not tokenizer.AtEnd():
1751  m = methods[i]
1752  if isinstance(m, str):
1753  token = tokenizer.token
1754  self.assertEqual(token, m)
1755  tokenizer.NextToken()
1756  elif isinstance(m[1], float) and math.isnan(m[1]):
1757  self.assertTrue(math.isnan(m[0]()))
1758  else:
1759  self.assertEqual(m[1], m[0]())
1760  i += 1
1761 
1762  def testConsumeAbstractIntegers(self):
1763  # This test only tests the failures in the integer parsing methods as well
1764  # as the '0' special cases.
1765  int64_max = (1 << 63) - 1
1766  uint32_max = (1 << 32) - 1
1767  text = '-1 %d %d' % (uint32_max + 1, int64_max + 1)
1768  tokenizer = text_format.Tokenizer(text.splitlines())
1769  self.assertEqual(-1, tokenizer.ConsumeInteger())
1770 
1771  self.assertEqual(uint32_max + 1, tokenizer.ConsumeInteger())
1772 
1773  self.assertEqual(int64_max + 1, tokenizer.ConsumeInteger())
1774  self.assertTrue(tokenizer.AtEnd())
1775 
1776  text = '-0 0 0 1.2'
1777  tokenizer = text_format.Tokenizer(text.splitlines())
1778  self.assertEqual(0, tokenizer.ConsumeInteger())
1779  self.assertEqual(0, tokenizer.ConsumeInteger())
1780  self.assertEqual(True, tokenizer.TryConsumeInteger())
1781  self.assertEqual(False, tokenizer.TryConsumeInteger())
1782  with self.assertRaises(text_format.ParseError):
1783  tokenizer.ConsumeInteger()
1784  self.assertEqual(1.2, tokenizer.ConsumeFloat())
1785  self.assertTrue(tokenizer.AtEnd())
1786 
1787  def testConsumeIntegers(self):
1788  # This test only tests the failures in the integer parsing methods as well
1789  # as the '0' special cases.
1790  int64_max = (1 << 63) - 1
1791  uint32_max = (1 << 32) - 1
1792  text = '-1 %d %d' % (uint32_max + 1, int64_max + 1)
1793  tokenizer = text_format.Tokenizer(text.splitlines())
1794  self.assertRaises(text_format.ParseError,
1795  text_format._ConsumeUint32, tokenizer)
1796  self.assertRaises(text_format.ParseError,
1797  text_format._ConsumeUint64, tokenizer)
1798  self.assertEqual(-1, text_format._ConsumeInt32(tokenizer))
1799 
1800  self.assertRaises(text_format.ParseError,
1801  text_format._ConsumeUint32, tokenizer)
1802  self.assertRaises(text_format.ParseError,
1803  text_format._ConsumeInt32, tokenizer)
1804  self.assertEqual(uint32_max + 1, text_format._ConsumeInt64(tokenizer))
1805 
1806  self.assertRaises(text_format.ParseError,
1807  text_format._ConsumeInt64, tokenizer)
1808  self.assertEqual(int64_max + 1, text_format._ConsumeUint64(tokenizer))
1809  self.assertTrue(tokenizer.AtEnd())
1810 
1811  text = '-0 -0 0 0'
1812  tokenizer = text_format.Tokenizer(text.splitlines())
1813  self.assertEqual(0, text_format._ConsumeUint32(tokenizer))
1814  self.assertEqual(0, text_format._ConsumeUint64(tokenizer))
1815  self.assertEqual(0, text_format._ConsumeUint32(tokenizer))
1816  self.assertEqual(0, text_format._ConsumeUint64(tokenizer))
1817  self.assertTrue(tokenizer.AtEnd())
1818 
1819  def testConsumeOctalIntegers(self):
1820  """Test support for C style octal integers."""
1821  text = '00 -00 04 0755 -010 007 -0033 08 -09 01'
1822  tokenizer = text_format.Tokenizer(text.splitlines())
1823  self.assertEqual(0, tokenizer.ConsumeInteger())
1824  self.assertEqual(0, tokenizer.ConsumeInteger())
1825  self.assertEqual(4, tokenizer.ConsumeInteger())
1826  self.assertEqual(0o755, tokenizer.ConsumeInteger())
1827  self.assertEqual(-0o10, tokenizer.ConsumeInteger())
1828  self.assertEqual(7, tokenizer.ConsumeInteger())
1829  self.assertEqual(-0o033, tokenizer.ConsumeInteger())
1830  with self.assertRaises(text_format.ParseError):
1831  tokenizer.ConsumeInteger() # 08
1832  tokenizer.NextToken()
1833  with self.assertRaises(text_format.ParseError):
1834  tokenizer.ConsumeInteger() # -09
1835  tokenizer.NextToken()
1836  self.assertEqual(1, tokenizer.ConsumeInteger())
1837  self.assertTrue(tokenizer.AtEnd())
1838 
1839  def testConsumeByteString(self):
1840  text = '"string1\''
1841  tokenizer = text_format.Tokenizer(text.splitlines())
1842  self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
1843 
1844  text = 'string1"'
1845  tokenizer = text_format.Tokenizer(text.splitlines())
1846  self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
1847 
1848  text = '\n"\\xt"'
1849  tokenizer = text_format.Tokenizer(text.splitlines())
1850  self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
1851 
1852  text = '\n"\\"'
1853  tokenizer = text_format.Tokenizer(text.splitlines())
1854  self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
1855 
1856  text = '\n"\\x"'
1857  tokenizer = text_format.Tokenizer(text.splitlines())
1858  self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
1859 
1860  def testConsumeBool(self):
1861  text = 'not-a-bool'
1862  tokenizer = text_format.Tokenizer(text.splitlines())
1863  self.assertRaises(text_format.ParseError, tokenizer.ConsumeBool)
1864 
1865  def testSkipComment(self):
1866  tokenizer = text_format.Tokenizer('# some comment'.splitlines())
1867  self.assertTrue(tokenizer.AtEnd())
1868  self.assertRaises(text_format.ParseError, tokenizer.ConsumeComment)
1869 
1870  def testConsumeComment(self):
1871  tokenizer = text_format.Tokenizer('# some comment'.splitlines(),
1872  skip_comments=False)
1873  self.assertFalse(tokenizer.AtEnd())
1874  self.assertEqual('# some comment', tokenizer.ConsumeComment())
1875  self.assertTrue(tokenizer.AtEnd())
1876 
1877  def testConsumeTwoComments(self):
1878  text = '# some comment\n# another comment'
1879  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1880  self.assertEqual('# some comment', tokenizer.ConsumeComment())
1881  self.assertFalse(tokenizer.AtEnd())
1882  self.assertEqual('# another comment', tokenizer.ConsumeComment())
1883  self.assertTrue(tokenizer.AtEnd())
1884 
1885  def testConsumeTrailingComment(self):
1886  text = 'some_number: 4\n# some comment'
1887  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1888  self.assertRaises(text_format.ParseError, tokenizer.ConsumeComment)
1889 
1890  self.assertEqual('some_number', tokenizer.ConsumeIdentifier())
1891  self.assertEqual(tokenizer.token, ':')
1892  tokenizer.NextToken()
1893  self.assertRaises(text_format.ParseError, tokenizer.ConsumeComment)
1894  self.assertEqual(4, tokenizer.ConsumeInteger())
1895  self.assertFalse(tokenizer.AtEnd())
1896 
1897  self.assertEqual('# some comment', tokenizer.ConsumeComment())
1898  self.assertTrue(tokenizer.AtEnd())
1899 
1900  def testConsumeLineComment(self):
1901  tokenizer = text_format.Tokenizer('# some comment'.splitlines(),
1902  skip_comments=False)
1903  self.assertFalse(tokenizer.AtEnd())
1904  self.assertEqual((False, '# some comment'),
1905  tokenizer.ConsumeCommentOrTrailingComment())
1906  self.assertTrue(tokenizer.AtEnd())
1907 
1908  def testConsumeTwoLineComments(self):
1909  text = '# some comment\n# another comment'
1910  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1911  self.assertEqual((False, '# some comment'),
1912  tokenizer.ConsumeCommentOrTrailingComment())
1913  self.assertFalse(tokenizer.AtEnd())
1914  self.assertEqual((False, '# another comment'),
1915  tokenizer.ConsumeCommentOrTrailingComment())
1916  self.assertTrue(tokenizer.AtEnd())
1917 
1918  def testConsumeAndCheckTrailingComment(self):
1919  text = 'some_number: 4 # some comment' # trailing comment on the same line
1920  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1921  self.assertRaises(text_format.ParseError,
1922  tokenizer.ConsumeCommentOrTrailingComment)
1923 
1924  self.assertEqual('some_number', tokenizer.ConsumeIdentifier())
1925  self.assertEqual(tokenizer.token, ':')
1926  tokenizer.NextToken()
1927  self.assertRaises(text_format.ParseError,
1928  tokenizer.ConsumeCommentOrTrailingComment)
1929  self.assertEqual(4, tokenizer.ConsumeInteger())
1930  self.assertFalse(tokenizer.AtEnd())
1931 
1932  self.assertEqual((True, '# some comment'),
1933  tokenizer.ConsumeCommentOrTrailingComment())
1934  self.assertTrue(tokenizer.AtEnd())
1935 
1936  def testHashinComment(self):
1937  text = 'some_number: 4 # some comment # not a new comment'
1938  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1939  self.assertEqual('some_number', tokenizer.ConsumeIdentifier())
1940  self.assertEqual(tokenizer.token, ':')
1941  tokenizer.NextToken()
1942  self.assertEqual(4, tokenizer.ConsumeInteger())
1943  self.assertEqual((True, '# some comment # not a new comment'),
1944  tokenizer.ConsumeCommentOrTrailingComment())
1945  self.assertTrue(tokenizer.AtEnd())
1946 
1947  def testHugeString(self):
1948  # With pathologic backtracking, fails with Forge OOM.
1949  text = '"' + 'a' * (10 * 1024 * 1024) + '"'
1950  tokenizer = text_format.Tokenizer(text.splitlines(), skip_comments=False)
1951  tokenizer.ConsumeString()
1952 
1953 
1954 # Tests for pretty printer functionality.
1955 @_parameterized.parameters((unittest_pb2), (unittest_proto3_arena_pb2))
1956 class PrettyPrinterTest(TextFormatBase):
1957 
1958  def testPrettyPrintNoMatch(self, message_module):
1959 
1960  def printer(message, indent, as_one_line):
1961  del message, indent, as_one_line
1962  return None
1963 
1964  message = message_module.TestAllTypes()
1965  msg = message.repeated_nested_message.add()
1966  msg.bb = 42
1967  self.CompareToGoldenText(
1968  text_format.MessageToString(
1969  message, as_one_line=True, message_formatter=printer),
1970  'repeated_nested_message { bb: 42 }')
1971 
1972  def testPrettyPrintOneLine(self, message_module):
1973 
1974  def printer(m, indent, as_one_line):
1975  del indent, as_one_line
1976  if m.DESCRIPTOR == message_module.TestAllTypes.NestedMessage.DESCRIPTOR:
1977  return 'My lucky number is %s' % m.bb
1978 
1979  message = message_module.TestAllTypes()
1980  msg = message.repeated_nested_message.add()
1981  msg.bb = 42
1982  self.CompareToGoldenText(
1983  text_format.MessageToString(
1984  message, as_one_line=True, message_formatter=printer),
1985  'repeated_nested_message { My lucky number is 42 }')
1986 
1987  def testPrettyPrintMultiLine(self, message_module):
1988 
1989  def printer(m, indent, as_one_line):
1990  if m.DESCRIPTOR == message_module.TestAllTypes.NestedMessage.DESCRIPTOR:
1991  line_deliminator = (' ' if as_one_line else '\n') + ' ' * indent
1992  return 'My lucky number is:%s%s' % (line_deliminator, m.bb)
1993  return None
1994 
1995  message = message_module.TestAllTypes()
1996  msg = message.repeated_nested_message.add()
1997  msg.bb = 42
1998  self.CompareToGoldenText(
1999  text_format.MessageToString(
2000  message, as_one_line=True, message_formatter=printer),
2001  'repeated_nested_message { My lucky number is: 42 }')
2002  self.CompareToGoldenText(
2003  text_format.MessageToString(
2004  message, as_one_line=False, message_formatter=printer),
2005  'repeated_nested_message {\n My lucky number is:\n 42\n}\n')
2006 
2007  def testPrettyPrintEntireMessage(self, message_module):
2008 
2009  def printer(m, indent, as_one_line):
2010  del indent, as_one_line
2011  if m.DESCRIPTOR == message_module.TestAllTypes.DESCRIPTOR:
2012  return 'The is the message!'
2013  return None
2014 
2015  message = message_module.TestAllTypes()
2016  self.CompareToGoldenText(
2017  text_format.MessageToString(
2018  message, as_one_line=False, message_formatter=printer),
2019  'The is the message!\n')
2020  self.CompareToGoldenText(
2021  text_format.MessageToString(
2022  message, as_one_line=True, message_formatter=printer),
2023  'The is the message!')
2024 
2025  def testPrettyPrintMultipleParts(self, message_module):
2026 
2027  def printer(m, indent, as_one_line):
2028  del indent, as_one_line
2029  if m.DESCRIPTOR == message_module.TestAllTypes.NestedMessage.DESCRIPTOR:
2030  return 'My lucky number is %s' % m.bb
2031  return None
2032 
2033  message = message_module.TestAllTypes()
2034  message.optional_int32 = 61
2035  msg = message.repeated_nested_message.add()
2036  msg.bb = 42
2037  msg = message.repeated_nested_message.add()
2038  msg.bb = 99
2039  msg = message.optional_nested_message
2040  msg.bb = 1
2041  self.CompareToGoldenText(
2042  text_format.MessageToString(
2043  message, as_one_line=True, message_formatter=printer),
2044  ('optional_int32: 61 '
2045  'optional_nested_message { My lucky number is 1 } '
2046  'repeated_nested_message { My lucky number is 42 } '
2047  'repeated_nested_message { My lucky number is 99 }'))
2048 
2049  out = text_format.TextWriter(False)
2050  text_format.PrintField(
2051  message_module.TestAllTypes.DESCRIPTOR.fields_by_name[
2052  'optional_nested_message'],
2053  message.optional_nested_message,
2054  out,
2055  message_formatter=printer)
2056  self.assertEqual(
2057  'optional_nested_message {\n My lucky number is 1\n}\n',
2058  out.getvalue())
2059  out.close()
2060 
2061  out = text_format.TextWriter(False)
2062  text_format.PrintFieldValue(
2063  message_module.TestAllTypes.DESCRIPTOR.fields_by_name[
2064  'optional_nested_message'],
2065  message.optional_nested_message,
2066  out,
2067  message_formatter=printer)
2068  self.assertEqual(
2069  '{\n My lucky number is 1\n}',
2070  out.getvalue())
2071  out.close()
2072 
2073 
2074 class WhitespaceTest(TextFormatBase):
2075 
2076  def setUp(self):
2077  self.out = text_format.TextWriter(False)
2078  self.addCleanup(self.out.close)
2079  self.message = unittest_pb2.NestedTestAllTypes()
2080  self.message.child.payload.optional_string = 'value'
2081  self.field = self.message.DESCRIPTOR.fields_by_name['child']
2082  self.value = self.message.child
2083 
2084  def testMessageToString(self):
2085  self.CompareToGoldenText(
2086  text_format.MessageToString(self.message),
2087  textwrap.dedent("""\
2088  child {
2089  payload {
2090  optional_string: "value"
2091  }
2092  }
2093  """))
2094 
2095  def testPrintMessage(self):
2096  text_format.PrintMessage(self.message, self.out)
2097  self.CompareToGoldenText(
2098  self.out.getvalue(),
2099  textwrap.dedent("""\
2100  child {
2101  payload {
2102  optional_string: "value"
2103  }
2104  }
2105  """))
2106 
2107  def testPrintField(self):
2108  text_format.PrintField(self.field, self.value, self.out)
2109  self.CompareToGoldenText(
2110  self.out.getvalue(),
2111  textwrap.dedent("""\
2112  child {
2113  payload {
2114  optional_string: "value"
2115  }
2116  }
2117  """))
2118 
2119  def testPrintFieldValue(self):
2120  text_format.PrintFieldValue(
2121  self.field, self.value, self.out)
2122  self.CompareToGoldenText(
2123  self.out.getvalue(),
2124  textwrap.dedent("""\
2125  {
2126  payload {
2127  optional_string: "value"
2128  }
2129  }"""))
2130 
2131 
2132 if __name__ == '__main__':
2133  unittest.main()
google::protobuf.internal.text_format_test.Proto2Tests.testMergeDuplicateExtensionScalars
def testMergeDuplicateExtensionScalars(self)
Definition: google/protobuf/internal/text_format_test.py:1373
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintUnknownFields
def testPrintUnknownFields(self)
Definition: google/protobuf/internal/text_format_test.py:837
google::protobuf.internal.text_format_test.Proto2Tests.testPrintAllExtensions
def testPrintAllExtensions(self)
Definition: google/protobuf/internal/text_format_test.py:1185
google::protobuf.internal.text_format_test.WhitespaceTest.value
value
Definition: google/protobuf/internal/text_format_test.py:2082
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeTrailingComment
def testConsumeTrailingComment(self)
Definition: google/protobuf/internal/text_format_test.py:1885
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintMapUsingCppImplementation
def testPrintMapUsingCppImplementation(self)
Definition: google/protobuf/internal/text_format_test.py:996
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeAbstractIntegers
def testConsumeAbstractIntegers(self)
Definition: google/protobuf/internal/text_format_test.py:1762
google::protobuf.internal.text_format_test.Proto2Tests.testPrintMessageSetByFieldNumber
def testPrintMessageSetByFieldNumber(self)
Definition: google/protobuf/internal/text_format_test.py:1072
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAny
def testPrintMessageExpandAny(self)
Definition: google/protobuf/internal/text_format_test.py:1465
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintExoticUnicodeSubclass
def testPrintExoticUnicodeSubclass(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:128
google::protobuf.internal.text_format_test.TextFormatParserTests
Definition: google/protobuf/internal/text_format_test.py:490
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseTrailingCommas
def testParseTrailingCommas(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:563
google::protobuf.internal.text_format_test.Proto2Tests.testParseDuplicateExtensionScalars
def testParseDuplicateExtensionScalars(self)
Definition: google/protobuf/internal/text_format_test.py:1381
google::protobuf.internal.text_format_test.PrettyPrinterTest.testPrettyPrintOneLine
def testPrettyPrintOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:1972
google::protobuf.internal.text_format_test.WhitespaceTest.out
out
Definition: google/protobuf/internal/text_format_test.py:2077
google::protobuf.internal.text_format_test.Proto2Tests.testParseEmptyGroup
def testParseEmptyGroup(self)
Definition: google/protobuf/internal/text_format_test.py:1410
google::protobuf.internal.text_format_test.Proto2Tests.testParseAllExtensions
def testParseAllExtensions(self)
Definition: google/protobuf/internal/text_format_test.py:1210
google::protobuf.internal.text_format_test.SimpleTextFormatTests.testQuoteMarksAreSingleChars
def testQuoteMarksAreSingleChars(self)
Definition: google/protobuf/internal/text_format_test.py:74
google::protobuf.text_format.TextWriter
Definition: text_format.py:99
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testMergeLinesGolden
def testMergeLinesGolden(self)
Definition: google/protobuf/internal/text_format_test.py:935
google::protobuf.internal.text_format_test.PrettyPrinterTest.testPrettyPrintNoMatch
def testPrettyPrintNoMatch(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:1958
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testParseLinesGolden
def testParseLinesGolden(self)
Definition: google/protobuf/internal/text_format_test.py:945
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testMapOrderEnforcement
def testMapOrderEnforcement(self)
Definition: google/protobuf/internal/text_format_test.py:1018
google::protobuf.internal.text_format_test.TextFormatParserTests._GOLDEN_BYTES
string _GOLDEN_BYTES
Definition: google/protobuf/internal/text_format_test.py:704
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintRepeatedFieldsAsOneLine
def testPrintRepeatedFieldsAsOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:147
google::protobuf.internal.text_format_test.Proto3Tests.testMergeExpandedAnyRepeated
def testMergeExpandedAnyRepeated(self)
Definition: google/protobuf/internal/text_format_test.py:1605
google::protobuf.internal.text_format_test.TokenizerTest
Definition: google/protobuf/internal/text_format_test.py:1683
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAnyAsOneLinePointyBrackets
def testPrintMessageExpandAnyAsOneLinePointyBrackets(self)
Definition: google/protobuf/internal/text_format_test.py:1547
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseMultipleOneof
def testParseMultipleOneof(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:683
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseStringFieldUnescape
def testParseStringFieldUnescape(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:655
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeOctalIntegers
def testConsumeOctalIntegers(self)
Definition: google/protobuf/internal/text_format_test.py:1819
google::protobuf.internal.text_format_test.TextFormatBase.CompareToGoldenText
def CompareToGoldenText(self, text, golden_text)
Definition: google/protobuf/internal/text_format_test.py:91
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseBytes
def testParseBytes(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:720
google::protobuf.internal.text_format_test.TextFormatParserTests._GOLDEN_UNICODE
string _GOLDEN_UNICODE
Definition: google/protobuf/internal/text_format_test.py:703
google::protobuf.internal.text_format_test.TextFormatParserTests._GOLDEN_STR_0
string _GOLDEN_STR_0
Definition: google/protobuf/internal/text_format_test.py:706
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintAllFieldsPointy
def testPrintAllFieldsPointy(self)
Definition: google/protobuf/internal/text_format_test.py:811
google::protobuf.internal.text_format_test.TextFormatParserTests._BYTES_SAMPLE
string _BYTES_SAMPLE
Definition: google/protobuf/internal/text_format_test.py:702
google::protobuf
Definition: data_proto2_to_proto3_util.h:12
google::protobuf.internal.text_format_test.TextFormatParserTests.testFromBytesFile
def testFromBytesFile(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:732
google::protobuf.internal.text_format_test.Proto3Tests.testMergeAlternativeUrl
def testMergeAlternativeUrl(self)
Definition: google/protobuf/internal/text_format_test.py:1636
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testParseGolden
def testParseGolden(self)
Definition: google/protobuf/internal/text_format_test.py:819
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintShortFormatRepeatedFields
def testPrintShortFormatRepeatedFields(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:192
google::protobuf.internal.text_format_test.Proto2Tests.testPrintMessageSet
def testPrintMessageSet(self)
Definition: google/protobuf/internal/text_format_test.py:1047
google::protobuf.internal.text_format_test.SimpleTextFormatTests
Definition: google/protobuf/internal/text_format_test.py:68
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintNestedMessageAsOneLine
def testPrintNestedMessageAsOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:139
google::protobuf.internal.text_format_test.TextFormatBase.CompareToGoldenFile
def CompareToGoldenFile(self, text, golden_filename)
Definition: google/protobuf/internal/text_format_test.py:87
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.VerifyPrintShortFormatRepeatedFields
def VerifyPrintShortFormatRepeatedFields(self, message_module, as_one_line)
Definition: google/protobuf/internal/text_format_test.py:159
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseDuplicateMessages
def testParseDuplicateMessages(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:762
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseBadIntValue
def testParseBadIntValue(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:647
google::protobuf.internal.text_format_test.TextFormatBase.ReadGolden
def ReadGolden(self, golden_filename)
Definition: google/protobuf/internal/text_format_test.py:82
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintFloatFormat
def testPrintFloatFormat(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:268
google::protobuf.internal.text_format_test.WhitespaceTest
Definition: google/protobuf/internal/text_format_test.py:2074
google::protobuf.internal.text_format_test.TextFormatParserTests.testFromUnicodeFile
def testFromUnicodeFile(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:740
google::protobuf.internal.text_format_test.TextFormatMessageToTextBytesTests.testMessageToBytes
def testMessageToBytes(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:457
google::protobuf.internal.text_format_test.WhitespaceTest.testPrintFieldValue
def testPrintFieldValue(self)
Definition: google/protobuf/internal/text_format_test.py:2119
google::protobuf.internal
Definition: python/google/protobuf/internal/__init__.py:1
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeAndCheckTrailingComment
def testConsumeAndCheckTrailingComment(self)
Definition: google/protobuf/internal/text_format_test.py:1918
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseEmptyText
def testParseEmptyText(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:604
google::protobuf.internal.text_format_test.TextFormatBase.RemoveRedundantZeros
def RemoveRedundantZeros(self, text)
Definition: google/protobuf/internal/text_format_test.py:94
google::protobuf.internal.text_format_test.TextFormatMergeTests.testMergeMultipleOneof
def testMergeMultipleOneof(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:799
google::protobuf.internal.text_format_test.TokenizerTest.testHugeString
def testHugeString(self)
Definition: google/protobuf/internal/text_format_test.py:1947
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintExoticAsOneLine
def testPrintExoticAsOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:203
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeTwoLineComments
def testConsumeTwoLineComments(self)
Definition: google/protobuf/internal/text_format_test.py:1908
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseAllFields
def testParseAllFields(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:492
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeTwoComments
def testConsumeTwoComments(self)
Definition: google/protobuf/internal/text_format_test.py:1877
google::protobuf.internal.text_format_test.Proto2Tests.testParseGroupNotClosed
def testParseGroupNotClosed(self)
Definition: google/protobuf/internal/text_format_test.py:1401
google::protobuf.internal.text_format_test.Proto3Tests.testMergeExpandedAnyDescriptorPoolMissingType
def testMergeExpandedAnyDescriptorPoolMissingType(self)
Definition: google/protobuf/internal/text_format_test.py:1648
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseOneof
def testParseOneof(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:676
google::protobuf.internal.text_format_test.PrettyPrinterTest.testPrettyPrintEntireMessage
def testPrettyPrintEntireMessage(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:2007
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintRawUtf8String
def testPrintRawUtf8String(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:253
update_failure_list.str
str
Definition: update_failure_list.py:41
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAnyAsOneLine
def testPrintMessageExpandAnyAsOneLine(self)
Definition: google/protobuf/internal/text_format_test.py:1534
google::protobuf.internal.text_format_test.Proto3Tests
Definition: google/protobuf/internal/text_format_test.py:1463
google::protobuf.internal.text_format_test.Proto2Tests.testParseMap
def testParseMap(self)
Definition: google/protobuf/internal/text_format_test.py:1425
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseExotic
def testParseExotic(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:538
google::protobuf.internal.text_format_test.TokenizerTest.testSkipComment
def testSkipComment(self)
Definition: google/protobuf/internal/text_format_test.py:1865
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseUnknownField
def testParseUnknownField(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:625
google::protobuf.internal.text_format_test.Proto2Tests.testParseMessageSet
def testParseMessageSet(self)
Definition: google/protobuf/internal/text_format_test.py:1107
google::protobuf.internal.text_format_test.TextFormatMessageToTextBytesTests.testEscapedUtf8ASCIIRoundTrip
def testEscapedUtf8ASCIIRoundTrip(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:475
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAnyPointyBrackets
def testPrintMessageExpandAnyPointyBrackets(self)
Definition: google/protobuf/internal/text_format_test.py:1520
google::protobuf.internal.text_format_test.Proto2Tests.testPrintAllExtensionsPointy
def testPrintAllExtensionsPointy(self)
Definition: google/protobuf/internal/text_format_test.py:1192
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testRoundTripExoticAsOneLine
def testRoundTripExoticAsOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:224
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseDuplicateScalars
def testParseDuplicateScalars(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:772
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeIntegers
def testConsumeIntegers(self)
Definition: google/protobuf/internal/text_format_test.py:1787
google::protobuf.internal.text_format_test.TextFormatParserTests._GOLDEN_BYTES_1
string _GOLDEN_BYTES_1
Definition: google/protobuf/internal/text_format_test.py:705
google::protobuf.internal.text_format_test.TextFormatMergeTests.testMergeDuplicateNestedMessageScalars
def testMergeDuplicateNestedMessageScalars(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:791
google::protobuf.internal.text_format_test.Proto2Tests.testParseBadIdentifier
def testParseBadIdentifier(self)
Definition: google/protobuf/internal/text_format_test.py:1344
google::protobuf.internal.text_format_test.Proto3Tests.testMergeExpandedAny
def testMergeExpandedAny(self)
Definition: google/protobuf/internal/text_format_test.py:1588
google::protobuf.internal.text_format_test.TextFormatMergeTests.testMergeDuplicateScalars
def testMergeDuplicateScalars(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:784
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseRepeatedMessageShortFormat
def testParseRepeatedMessageShortFormat(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:592
google::protobuf.internal.text_format_test.TextFormatParserTests._UNICODE_SAMPLE
string _UNICODE_SAMPLE
Definition: google/protobuf/internal/text_format_test.py:695
google::protobuf.internal.text_format_test.PrettyPrinterTest
Definition: google/protobuf/internal/text_format_test.py:1956
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeBool
def testConsumeBool(self)
Definition: google/protobuf/internal/text_format_test.py:1860
google::protobuf.internal.text_format_test.WhitespaceTest.field
field
Definition: google/protobuf/internal/text_format_test.py:2081
google::protobuf.internal.text_format_test.WhitespaceTest.message
message
Definition: google/protobuf/internal/text_format_test.py:2079
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testMessageToString
def testMessageToString(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:331
google::protobuf.internal.text_format_test.TextFormatParserTests.testFromBytesLines
def testFromBytesLines(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:748
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintExotic
def testPrintExotic(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:108
google::protobuf.internal.text_format_test.TextFormatBase
Definition: google/protobuf/internal/text_format_test.py:80
google::protobuf.internal.text_format_test.Proto3Tests.testTopAnyMessage
def testTopAnyMessage(self)
Definition: google/protobuf/internal/text_format_test.py:1479
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintField
def testPrintField(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:366
google::protobuf.internal.text_format_test.WhitespaceTest.setUp
def setUp(self)
Definition: google/protobuf/internal/text_format_test.py:2076
google::protobuf.text_format.Tokenizer
Definition: text_format.py:1178
google::protobuf.internal.text_format_test.PrettyPrinterTest.testPrettyPrintMultipleParts
def testPrettyPrintMultipleParts(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:2025
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintInIndexOrder
def testPrintInIndexOrder(self)
Definition: google/protobuf/internal/text_format_test.py:870
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseDoubleToFloat
def testParseDoubleToFloat(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:530
len
int len
Definition: php/ext/google/protobuf/map.c:206
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testCustomOptions
def testCustomOptions(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:396
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintNestedNewLineInStringAsOneLine
def testPrintNestedNewLineInStringAsOneLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:196
google::protobuf.internal.text_format_test.TextFormatParserTests.testFromUnicodeLines
def testFromUnicodeLines(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:755
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeComment
def testConsumeComment(self)
Definition: google/protobuf/internal/text_format_test.py:1870
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testMessageToStringASCII
def testMessageToStringASCII(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:350
google::protobuf.internal.text_format_test.Proto2Tests.testParseNumericUnknownEnum
def testParseNumericUnknownEnum(self)
Definition: google/protobuf/internal/text_format_test.py:1364
google::protobuf.internal.text_format_test.Proto2Tests.testExtensionInsideAnyMessage
def testExtensionInsideAnyMessage(self)
Definition: google/protobuf/internal/text_format_test.py:1129
google::protobuf.internal.text_format_test.Proto3Tests.testPrintAndParseMessageInvalidAny
def testPrintAndParseMessageInvalidAny(self)
Definition: google/protobuf/internal/text_format_test.py:1562
google::protobuf.internal.text_format_test.Proto2Tests
Definition: google/protobuf/internal/text_format_test.py:1045
google::protobuf.internal.text_format_test.Proto3Tests.testMergeExpandedAnyPointyBrackets
def testMergeExpandedAnyPointyBrackets(self)
Definition: google/protobuf/internal/text_format_test.py:1624
google::protobuf.text_format.ParseError
Definition: text_format.py:76
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseInvalidUtf8
def testParseInvalidUtf8(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:610
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeByteString
def testConsumeByteString(self)
Definition: google/protobuf/internal/text_format_test.py:1839
google::protobuf.descriptor_pool.DescriptorPool
Definition: descriptor_pool.py:102
google::protobuf.internal.text_format_test.Proto2Tests.testParseGoldenExtensions
def testParseGoldenExtensions(self)
Definition: google/protobuf/internal/text_format_test.py:1200
google::protobuf.internal.text_format_test.WhitespaceTest.testPrintMessage
def testPrintMessage(self)
Definition: google/protobuf/internal/text_format_test.py:2095
google::protobuf.text_format._Printer
Definition: text_format.py:307
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseRepeatedScalarShortFormat
def testParseRepeatedScalarShortFormat(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:578
google::protobuf.internal.text_format_test.TokenizerTest.testConsumeLineComment
def testConsumeLineComment(self)
Definition: google/protobuf/internal/text_format_test.py:1900
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests
Definition: google/protobuf/internal/text_format_test.py:809
google::protobuf.internal.text_format_test.Proto2Tests.testPrintMessageSetAsOneLine
def testPrintMessageSetAsOneLine(self)
Definition: google/protobuf/internal/text_format_test.py:1090
google::protobuf.internal.text_format_test.TokenizerTest.testSimpleTokenCases
def testSimpleTokenCases(self)
Definition: google/protobuf/internal/text_format_test.py:1685
google::protobuf.internal.text_format_test.Proto2Tests.testParseBadExtension
def testParseBadExtension(self)
Definition: google/protobuf/internal/text_format_test.py:1353
google::protobuf.internal.text_format_test.Proto3Tests.testUnknownEnums
def testUnknownEnums(self)
Definition: google/protobuf/internal/text_format_test.py:1580
google::protobuf.internal.text_format_test.Proto2Tests.testParseDuplicateExtensionMessages
def testParseDuplicateExtensionMessages(self)
Definition: google/protobuf/internal/text_format_test.py:1391
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseBadEnumValue
def testParseBadEnumValue(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:638
google::protobuf.internal.text_format_test.Proto3Tests.testMergeMissingAnyEndToken
def testMergeMissingAnyEndToken(self)
Definition: google/protobuf/internal/text_format_test.py:1673
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testMessageToStringUnicode
def testMessageToStringUnicode(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:336
cpp.ast.reversed
def reversed(seq)
Definition: ast.py:52
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintAllFields
def testPrintAllFields(self)
Definition: google/protobuf/internal/text_format_test.py:830
google::protobuf.internal.text_format_test.Proto3Tests.testMergeUnexpandedAny
def testMergeUnexpandedAny(self)
Definition: google/protobuf/internal/text_format_test.py:1662
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests.testPrintFieldValue
def testPrintFieldValue(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:381
google::protobuf.internal.text_format_test.Proto2Tests.testParseAllowedUnknownExtension
def testParseAllowedUnknownExtension(self)
Definition: google/protobuf/internal/text_format_test.py:1219
google::protobuf.internal.text_format_test.WhitespaceTest.testPrintField
def testPrintField(self)
Definition: google/protobuf/internal/text_format_test.py:2107
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAnyDescriptorPoolMissingType
def testPrintMessageExpandAnyDescriptorPoolMissingType(self)
Definition: google/protobuf/internal/text_format_test.py:1507
google::protobuf.internal.text_format_test.TextFormatMergeTests
Definition: google/protobuf/internal/text_format_test.py:782
google::protobuf.internal.text_format_test.Proto2Tests.testParseMessageByFieldNumber
def testParseMessageByFieldNumber(self)
Definition: google/protobuf/internal/text_format_test.py:1144
google::protobuf.internal.text_format_test.TextFormatMessageToStringTests
Definition: google/protobuf/internal/text_format_test.py:106
google::protobuf.internal.text_format_test.TextFormatMessageToTextBytesTests
Definition: google/protobuf/internal/text_format_test.py:455
google::protobuf.internal.text_format_test.WhitespaceTest.testMessageToString
def testMessageToString(self)
Definition: google/protobuf/internal/text_format_test.py:2084
google::protobuf.internal.text_format_test.TextFormatMessageToTextBytesTests.testRawUtf8RoundTrip
def testRawUtf8RoundTrip(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:462
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseUnicode
def testParseUnicode(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:708
google::protobuf.internal.text_format_test.PrettyPrinterTest.testPrettyPrintMultiLine
def testPrettyPrintMultiLine(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:1987
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseSingleWord
def testParseSingleWord(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:618
google::protobuf.internal.text_format_test.TextFormatParserTests.testParseAndMergeUtf8
def testParseAndMergeUtf8(self, message_module)
Definition: google/protobuf/internal/text_format_test.py:503
google::protobuf.internal.text_format_test.OnlyWorksWithProto2RightNowTests.testPrintMap
def testPrintMap(self)
Definition: google/protobuf/internal/text_format_test.py:955
google::protobuf.internal.text_format_test.TokenizerTest.testHashinComment
def testHashinComment(self)
Definition: google/protobuf/internal/text_format_test.py:1936
google::protobuf.internal.text_format_test.Proto3Tests.testPrintMessageExpandAnyRepeated
def testPrintMessageExpandAnyRepeated(self)
Definition: google/protobuf/internal/text_format_test.py:1487

libaditof
Author(s):
autogenerated on Wed May 21 2025 02:07:00