/thirdparty/breakpad/third_party/protobuf/protobuf/python/google/protobuf/internal/text_format_test.py

http://github.com/tomahawk-player/tomahawk · Python · 571 lines · 461 code · 68 blank · 42 comment · 10 complexity · 166cac120fffa6225b078b1c6436b1f2 MD5 · raw file

  1. #! /usr/bin/python
  2. #
  3. # Protocol Buffers - Google's data interchange format
  4. # Copyright 2008 Google Inc. All rights reserved.
  5. # http://code.google.com/p/protobuf/
  6. #
  7. # Redistribution and use in source and binary forms, with or without
  8. # modification, are permitted provided that the following conditions are
  9. # met:
  10. #
  11. # * Redistributions of source code must retain the above copyright
  12. # notice, this list of conditions and the following disclaimer.
  13. # * Redistributions in binary form must reproduce the above
  14. # copyright notice, this list of conditions and the following disclaimer
  15. # in the documentation and/or other materials provided with the
  16. # distribution.
  17. # * Neither the name of Google Inc. nor the names of its
  18. # contributors may be used to endorse or promote products derived from
  19. # this software without specific prior written permission.
  20. #
  21. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22. # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23. # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24. # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25. # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26. # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27. # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28. # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29. # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30. # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32. """Test for google.protobuf.text_format."""
  33. __author__ = 'kenton@google.com (Kenton Varda)'
  34. import difflib
  35. import re
  36. import unittest
  37. from google.protobuf import text_format
  38. from google.protobuf.internal import test_util
  39. from google.protobuf import unittest_pb2
  40. from google.protobuf import unittest_mset_pb2
  41. class TextFormatTest(unittest.TestCase):
  42. def ReadGolden(self, golden_filename):
  43. f = test_util.GoldenFile(golden_filename)
  44. golden_lines = f.readlines()
  45. f.close()
  46. return golden_lines
  47. def CompareToGoldenFile(self, text, golden_filename):
  48. golden_lines = self.ReadGolden(golden_filename)
  49. self.CompareToGoldenLines(text, golden_lines)
  50. def CompareToGoldenText(self, text, golden_text):
  51. self.CompareToGoldenLines(text, golden_text.splitlines(1))
  52. def CompareToGoldenLines(self, text, golden_lines):
  53. actual_lines = text.splitlines(1)
  54. self.assertEqual(golden_lines, actual_lines,
  55. "Text doesn't match golden. Diff:\n" +
  56. ''.join(difflib.ndiff(golden_lines, actual_lines)))
  57. def testPrintAllFields(self):
  58. message = unittest_pb2.TestAllTypes()
  59. test_util.SetAllFields(message)
  60. self.CompareToGoldenFile(
  61. self.RemoveRedundantZeros(text_format.MessageToString(message)),
  62. 'text_format_unittest_data.txt')
  63. def testPrintAllExtensions(self):
  64. message = unittest_pb2.TestAllExtensions()
  65. test_util.SetAllExtensions(message)
  66. self.CompareToGoldenFile(
  67. self.RemoveRedundantZeros(text_format.MessageToString(message)),
  68. 'text_format_unittest_extensions_data.txt')
  69. def testPrintMessageSet(self):
  70. message = unittest_mset_pb2.TestMessageSetContainer()
  71. ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
  72. ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
  73. message.message_set.Extensions[ext1].i = 23
  74. message.message_set.Extensions[ext2].str = 'foo'
  75. self.CompareToGoldenText(text_format.MessageToString(message),
  76. 'message_set {\n'
  77. ' [protobuf_unittest.TestMessageSetExtension1] {\n'
  78. ' i: 23\n'
  79. ' }\n'
  80. ' [protobuf_unittest.TestMessageSetExtension2] {\n'
  81. ' str: \"foo\"\n'
  82. ' }\n'
  83. '}\n')
  84. def testPrintExotic(self):
  85. message = unittest_pb2.TestAllTypes()
  86. message.repeated_int64.append(-9223372036854775808)
  87. message.repeated_uint64.append(18446744073709551615)
  88. message.repeated_double.append(123.456)
  89. message.repeated_double.append(1.23e22)
  90. message.repeated_double.append(1.23e-18)
  91. message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
  92. message.repeated_string.append(u'\u00fc\ua71f')
  93. self.CompareToGoldenText(
  94. self.RemoveRedundantZeros(text_format.MessageToString(message)),
  95. 'repeated_int64: -9223372036854775808\n'
  96. 'repeated_uint64: 18446744073709551615\n'
  97. 'repeated_double: 123.456\n'
  98. 'repeated_double: 1.23e+22\n'
  99. 'repeated_double: 1.23e-18\n'
  100. 'repeated_string: '
  101. '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n'
  102. 'repeated_string: "\\303\\274\\352\\234\\237"\n')
  103. def testPrintNestedMessageAsOneLine(self):
  104. message = unittest_pb2.TestAllTypes()
  105. msg = message.repeated_nested_message.add()
  106. msg.bb = 42;
  107. self.CompareToGoldenText(
  108. text_format.MessageToString(message, as_one_line=True),
  109. 'repeated_nested_message { bb: 42 }')
  110. def testPrintRepeatedFieldsAsOneLine(self):
  111. message = unittest_pb2.TestAllTypes()
  112. message.repeated_int32.append(1)
  113. message.repeated_int32.append(1)
  114. message.repeated_int32.append(3)
  115. message.repeated_string.append("Google")
  116. message.repeated_string.append("Zurich")
  117. self.CompareToGoldenText(
  118. text_format.MessageToString(message, as_one_line=True),
  119. 'repeated_int32: 1 repeated_int32: 1 repeated_int32: 3 '
  120. 'repeated_string: "Google" repeated_string: "Zurich"')
  121. def testPrintNestedNewLineInStringAsOneLine(self):
  122. message = unittest_pb2.TestAllTypes()
  123. message.optional_string = "a\nnew\nline"
  124. self.CompareToGoldenText(
  125. text_format.MessageToString(message, as_one_line=True),
  126. 'optional_string: "a\\nnew\\nline"')
  127. def testPrintMessageSetAsOneLine(self):
  128. message = unittest_mset_pb2.TestMessageSetContainer()
  129. ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
  130. ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
  131. message.message_set.Extensions[ext1].i = 23
  132. message.message_set.Extensions[ext2].str = 'foo'
  133. self.CompareToGoldenText(
  134. text_format.MessageToString(message, as_one_line=True),
  135. 'message_set {'
  136. ' [protobuf_unittest.TestMessageSetExtension1] {'
  137. ' i: 23'
  138. ' }'
  139. ' [protobuf_unittest.TestMessageSetExtension2] {'
  140. ' str: \"foo\"'
  141. ' }'
  142. ' }')
  143. def testPrintExoticAsOneLine(self):
  144. message = unittest_pb2.TestAllTypes()
  145. message.repeated_int64.append(-9223372036854775808)
  146. message.repeated_uint64.append(18446744073709551615)
  147. message.repeated_double.append(123.456)
  148. message.repeated_double.append(1.23e22)
  149. message.repeated_double.append(1.23e-18)
  150. message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
  151. message.repeated_string.append(u'\u00fc\ua71f')
  152. self.CompareToGoldenText(
  153. self.RemoveRedundantZeros(
  154. text_format.MessageToString(message, as_one_line=True)),
  155. 'repeated_int64: -9223372036854775808'
  156. ' repeated_uint64: 18446744073709551615'
  157. ' repeated_double: 123.456'
  158. ' repeated_double: 1.23e+22'
  159. ' repeated_double: 1.23e-18'
  160. ' repeated_string: '
  161. '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""'
  162. ' repeated_string: "\\303\\274\\352\\234\\237"')
  163. def testRoundTripExoticAsOneLine(self):
  164. message = unittest_pb2.TestAllTypes()
  165. message.repeated_int64.append(-9223372036854775808)
  166. message.repeated_uint64.append(18446744073709551615)
  167. message.repeated_double.append(123.456)
  168. message.repeated_double.append(1.23e22)
  169. message.repeated_double.append(1.23e-18)
  170. message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"')
  171. message.repeated_string.append(u'\u00fc\ua71f')
  172. # Test as_utf8 = False.
  173. wire_text = text_format.MessageToString(
  174. message, as_one_line=True, as_utf8=False)
  175. parsed_message = unittest_pb2.TestAllTypes()
  176. text_format.Merge(wire_text, parsed_message)
  177. self.assertEquals(message, parsed_message)
  178. # Test as_utf8 = True.
  179. wire_text = text_format.MessageToString(
  180. message, as_one_line=True, as_utf8=True)
  181. parsed_message = unittest_pb2.TestAllTypes()
  182. text_format.Merge(wire_text, parsed_message)
  183. self.assertEquals(message, parsed_message)
  184. def testPrintRawUtf8String(self):
  185. message = unittest_pb2.TestAllTypes()
  186. message.repeated_string.append(u'\u00fc\ua71f')
  187. text = text_format.MessageToString(message, as_utf8 = True)
  188. self.CompareToGoldenText(text, 'repeated_string: "\303\274\352\234\237"\n')
  189. parsed_message = unittest_pb2.TestAllTypes()
  190. text_format.Merge(text, parsed_message)
  191. self.assertEquals(message, parsed_message)
  192. def testMessageToString(self):
  193. message = unittest_pb2.ForeignMessage()
  194. message.c = 123
  195. self.assertEqual('c: 123\n', str(message))
  196. def RemoveRedundantZeros(self, text):
  197. # Some platforms print 1e+5 as 1e+005. This is fine, but we need to remove
  198. # these zeros in order to match the golden file.
  199. text = text.replace('e+0','e+').replace('e+0','e+') \
  200. .replace('e-0','e-').replace('e-0','e-')
  201. # Floating point fields are printed with .0 suffix even if they are
  202. # actualy integer numbers.
  203. text = re.compile('\.0$', re.MULTILINE).sub('', text)
  204. return text
  205. def testMergeGolden(self):
  206. golden_text = '\n'.join(self.ReadGolden('text_format_unittest_data.txt'))
  207. parsed_message = unittest_pb2.TestAllTypes()
  208. text_format.Merge(golden_text, parsed_message)
  209. message = unittest_pb2.TestAllTypes()
  210. test_util.SetAllFields(message)
  211. self.assertEquals(message, parsed_message)
  212. def testMergeGoldenExtensions(self):
  213. golden_text = '\n'.join(self.ReadGolden(
  214. 'text_format_unittest_extensions_data.txt'))
  215. parsed_message = unittest_pb2.TestAllExtensions()
  216. text_format.Merge(golden_text, parsed_message)
  217. message = unittest_pb2.TestAllExtensions()
  218. test_util.SetAllExtensions(message)
  219. self.assertEquals(message, parsed_message)
  220. def testMergeAllFields(self):
  221. message = unittest_pb2.TestAllTypes()
  222. test_util.SetAllFields(message)
  223. ascii_text = text_format.MessageToString(message)
  224. parsed_message = unittest_pb2.TestAllTypes()
  225. text_format.Merge(ascii_text, parsed_message)
  226. self.assertEqual(message, parsed_message)
  227. test_util.ExpectAllFieldsSet(self, message)
  228. def testMergeAllExtensions(self):
  229. message = unittest_pb2.TestAllExtensions()
  230. test_util.SetAllExtensions(message)
  231. ascii_text = text_format.MessageToString(message)
  232. parsed_message = unittest_pb2.TestAllExtensions()
  233. text_format.Merge(ascii_text, parsed_message)
  234. self.assertEqual(message, parsed_message)
  235. def testMergeMessageSet(self):
  236. message = unittest_pb2.TestAllTypes()
  237. text = ('repeated_uint64: 1\n'
  238. 'repeated_uint64: 2\n')
  239. text_format.Merge(text, message)
  240. self.assertEqual(1, message.repeated_uint64[0])
  241. self.assertEqual(2, message.repeated_uint64[1])
  242. message = unittest_mset_pb2.TestMessageSetContainer()
  243. text = ('message_set {\n'
  244. ' [protobuf_unittest.TestMessageSetExtension1] {\n'
  245. ' i: 23\n'
  246. ' }\n'
  247. ' [protobuf_unittest.TestMessageSetExtension2] {\n'
  248. ' str: \"foo\"\n'
  249. ' }\n'
  250. '}\n')
  251. text_format.Merge(text, message)
  252. ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
  253. ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
  254. self.assertEquals(23, message.message_set.Extensions[ext1].i)
  255. self.assertEquals('foo', message.message_set.Extensions[ext2].str)
  256. def testMergeExotic(self):
  257. message = unittest_pb2.TestAllTypes()
  258. text = ('repeated_int64: -9223372036854775808\n'
  259. 'repeated_uint64: 18446744073709551615\n'
  260. 'repeated_double: 123.456\n'
  261. 'repeated_double: 1.23e+22\n'
  262. 'repeated_double: 1.23e-18\n'
  263. 'repeated_string: \n'
  264. '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n'
  265. 'repeated_string: "foo" \'corge\' "grault"\n'
  266. 'repeated_string: "\\303\\274\\352\\234\\237"\n'
  267. 'repeated_string: "\\xc3\\xbc"\n'
  268. 'repeated_string: "\xc3\xbc"\n')
  269. text_format.Merge(text, message)
  270. self.assertEqual(-9223372036854775808, message.repeated_int64[0])
  271. self.assertEqual(18446744073709551615, message.repeated_uint64[0])
  272. self.assertEqual(123.456, message.repeated_double[0])
  273. self.assertEqual(1.23e22, message.repeated_double[1])
  274. self.assertEqual(1.23e-18, message.repeated_double[2])
  275. self.assertEqual(
  276. '\000\001\a\b\f\n\r\t\v\\\'"', message.repeated_string[0])
  277. self.assertEqual('foocorgegrault', message.repeated_string[1])
  278. self.assertEqual(u'\u00fc\ua71f', message.repeated_string[2])
  279. self.assertEqual(u'\u00fc', message.repeated_string[3])
  280. def testMergeEmptyText(self):
  281. message = unittest_pb2.TestAllTypes()
  282. text = ''
  283. text_format.Merge(text, message)
  284. self.assertEquals(unittest_pb2.TestAllTypes(), message)
  285. def testMergeInvalidUtf8(self):
  286. message = unittest_pb2.TestAllTypes()
  287. text = 'repeated_string: "\\xc3\\xc3"'
  288. self.assertRaises(text_format.ParseError, text_format.Merge, text, message)
  289. def testMergeSingleWord(self):
  290. message = unittest_pb2.TestAllTypes()
  291. text = 'foo'
  292. self.assertRaisesWithMessage(
  293. text_format.ParseError,
  294. ('1:1 : Message type "protobuf_unittest.TestAllTypes" has no field named '
  295. '"foo".'),
  296. text_format.Merge, text, message)
  297. def testMergeUnknownField(self):
  298. message = unittest_pb2.TestAllTypes()
  299. text = 'unknown_field: 8\n'
  300. self.assertRaisesWithMessage(
  301. text_format.ParseError,
  302. ('1:1 : Message type "protobuf_unittest.TestAllTypes" has no field named '
  303. '"unknown_field".'),
  304. text_format.Merge, text, message)
  305. def testMergeBadExtension(self):
  306. message = unittest_pb2.TestAllExtensions()
  307. text = '[unknown_extension]: 8\n'
  308. self.assertRaisesWithMessage(
  309. text_format.ParseError,
  310. '1:2 : Extension "unknown_extension" not registered.',
  311. text_format.Merge, text, message)
  312. message = unittest_pb2.TestAllTypes()
  313. self.assertRaisesWithMessage(
  314. text_format.ParseError,
  315. ('1:2 : Message type "protobuf_unittest.TestAllTypes" does not have '
  316. 'extensions.'),
  317. text_format.Merge, text, message)
  318. def testMergeGroupNotClosed(self):
  319. message = unittest_pb2.TestAllTypes()
  320. text = 'RepeatedGroup: <'
  321. self.assertRaisesWithMessage(
  322. text_format.ParseError, '1:16 : Expected ">".',
  323. text_format.Merge, text, message)
  324. text = 'RepeatedGroup: {'
  325. self.assertRaisesWithMessage(
  326. text_format.ParseError, '1:16 : Expected "}".',
  327. text_format.Merge, text, message)
  328. def testMergeEmptyGroup(self):
  329. message = unittest_pb2.TestAllTypes()
  330. text = 'OptionalGroup: {}'
  331. text_format.Merge(text, message)
  332. self.assertTrue(message.HasField('optionalgroup'))
  333. message.Clear()
  334. message = unittest_pb2.TestAllTypes()
  335. text = 'OptionalGroup: <>'
  336. text_format.Merge(text, message)
  337. self.assertTrue(message.HasField('optionalgroup'))
  338. def testMergeBadEnumValue(self):
  339. message = unittest_pb2.TestAllTypes()
  340. text = 'optional_nested_enum: BARR'
  341. self.assertRaisesWithMessage(
  342. text_format.ParseError,
  343. ('1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
  344. 'has no value named BARR.'),
  345. text_format.Merge, text, message)
  346. message = unittest_pb2.TestAllTypes()
  347. text = 'optional_nested_enum: 100'
  348. self.assertRaisesWithMessage(
  349. text_format.ParseError,
  350. ('1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
  351. 'has no value with number 100.'),
  352. text_format.Merge, text, message)
  353. def assertRaisesWithMessage(self, e_class, e, func, *args, **kwargs):
  354. """Same as assertRaises, but also compares the exception message."""
  355. if hasattr(e_class, '__name__'):
  356. exc_name = e_class.__name__
  357. else:
  358. exc_name = str(e_class)
  359. try:
  360. func(*args, **kwargs)
  361. except e_class, expr:
  362. if str(expr) != e:
  363. msg = '%s raised, but with wrong message: "%s" instead of "%s"'
  364. raise self.failureException(msg % (exc_name,
  365. str(expr).encode('string_escape'),
  366. e.encode('string_escape')))
  367. return
  368. else:
  369. raise self.failureException('%s not raised' % exc_name)
  370. class TokenizerTest(unittest.TestCase):
  371. def testSimpleTokenCases(self):
  372. text = ('identifier1:"string1"\n \n\n'
  373. 'identifier2 : \n \n123 \n identifier3 :\'string\'\n'
  374. 'identifiER_4 : 1.1e+2 ID5:-0.23 ID6:\'aaaa\\\'bbbb\'\n'
  375. 'ID7 : "aa\\"bb"\n\n\n\n ID8: {A:inf B:-inf C:true D:false}\n'
  376. 'ID9: 22 ID10: -111111111111111111 ID11: -22\n'
  377. 'ID12: 2222222222222222222 '
  378. 'false_bool: 0 true_BOOL:t \n true_bool1: 1 false_BOOL1:f ' )
  379. tokenizer = text_format._Tokenizer(text)
  380. methods = [(tokenizer.ConsumeIdentifier, 'identifier1'),
  381. ':',
  382. (tokenizer.ConsumeString, 'string1'),
  383. (tokenizer.ConsumeIdentifier, 'identifier2'),
  384. ':',
  385. (tokenizer.ConsumeInt32, 123),
  386. (tokenizer.ConsumeIdentifier, 'identifier3'),
  387. ':',
  388. (tokenizer.ConsumeString, 'string'),
  389. (tokenizer.ConsumeIdentifier, 'identifiER_4'),
  390. ':',
  391. (tokenizer.ConsumeFloat, 1.1e+2),
  392. (tokenizer.ConsumeIdentifier, 'ID5'),
  393. ':',
  394. (tokenizer.ConsumeFloat, -0.23),
  395. (tokenizer.ConsumeIdentifier, 'ID6'),
  396. ':',
  397. (tokenizer.ConsumeString, 'aaaa\'bbbb'),
  398. (tokenizer.ConsumeIdentifier, 'ID7'),
  399. ':',
  400. (tokenizer.ConsumeString, 'aa\"bb'),
  401. (tokenizer.ConsumeIdentifier, 'ID8'),
  402. ':',
  403. '{',
  404. (tokenizer.ConsumeIdentifier, 'A'),
  405. ':',
  406. (tokenizer.ConsumeFloat, text_format._INFINITY),
  407. (tokenizer.ConsumeIdentifier, 'B'),
  408. ':',
  409. (tokenizer.ConsumeFloat, -text_format._INFINITY),
  410. (tokenizer.ConsumeIdentifier, 'C'),
  411. ':',
  412. (tokenizer.ConsumeBool, True),
  413. (tokenizer.ConsumeIdentifier, 'D'),
  414. ':',
  415. (tokenizer.ConsumeBool, False),
  416. '}',
  417. (tokenizer.ConsumeIdentifier, 'ID9'),
  418. ':',
  419. (tokenizer.ConsumeUint32, 22),
  420. (tokenizer.ConsumeIdentifier, 'ID10'),
  421. ':',
  422. (tokenizer.ConsumeInt64, -111111111111111111),
  423. (tokenizer.ConsumeIdentifier, 'ID11'),
  424. ':',
  425. (tokenizer.ConsumeInt32, -22),
  426. (tokenizer.ConsumeIdentifier, 'ID12'),
  427. ':',
  428. (tokenizer.ConsumeUint64, 2222222222222222222),
  429. (tokenizer.ConsumeIdentifier, 'false_bool'),
  430. ':',
  431. (tokenizer.ConsumeBool, False),
  432. (tokenizer.ConsumeIdentifier, 'true_BOOL'),
  433. ':',
  434. (tokenizer.ConsumeBool, True),
  435. (tokenizer.ConsumeIdentifier, 'true_bool1'),
  436. ':',
  437. (tokenizer.ConsumeBool, True),
  438. (tokenizer.ConsumeIdentifier, 'false_BOOL1'),
  439. ':',
  440. (tokenizer.ConsumeBool, False)]
  441. i = 0
  442. while not tokenizer.AtEnd():
  443. m = methods[i]
  444. if type(m) == str:
  445. token = tokenizer.token
  446. self.assertEqual(token, m)
  447. tokenizer.NextToken()
  448. else:
  449. self.assertEqual(m[1], m[0]())
  450. i += 1
  451. def testConsumeIntegers(self):
  452. # This test only tests the failures in the integer parsing methods as well
  453. # as the '0' special cases.
  454. int64_max = (1 << 63) - 1
  455. uint32_max = (1 << 32) - 1
  456. text = '-1 %d %d' % (uint32_max + 1, int64_max + 1)
  457. tokenizer = text_format._Tokenizer(text)
  458. self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
  459. self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint64)
  460. self.assertEqual(-1, tokenizer.ConsumeInt32())
  461. self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
  462. self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt32)
  463. self.assertEqual(uint32_max + 1, tokenizer.ConsumeInt64())
  464. self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt64)
  465. self.assertEqual(int64_max + 1, tokenizer.ConsumeUint64())
  466. self.assertTrue(tokenizer.AtEnd())
  467. text = '-0 -0 0 0'
  468. tokenizer = text_format._Tokenizer(text)
  469. self.assertEqual(0, tokenizer.ConsumeUint32())
  470. self.assertEqual(0, tokenizer.ConsumeUint64())
  471. self.assertEqual(0, tokenizer.ConsumeUint32())
  472. self.assertEqual(0, tokenizer.ConsumeUint64())
  473. self.assertTrue(tokenizer.AtEnd())
  474. def testConsumeByteString(self):
  475. text = '"string1\''
  476. tokenizer = text_format._Tokenizer(text)
  477. self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
  478. text = 'string1"'
  479. tokenizer = text_format._Tokenizer(text)
  480. self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
  481. text = '\n"\\xt"'
  482. tokenizer = text_format._Tokenizer(text)
  483. self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
  484. text = '\n"\\"'
  485. tokenizer = text_format._Tokenizer(text)
  486. self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
  487. text = '\n"\\x"'
  488. tokenizer = text_format._Tokenizer(text)
  489. self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
  490. def testConsumeBool(self):
  491. text = 'not-a-bool'
  492. tokenizer = text_format._Tokenizer(text)
  493. self.assertRaises(text_format.ParseError, tokenizer.ConsumeBool)
  494. def testInfNan(self):
  495. # Make sure our infinity and NaN definitions are sound.
  496. self.assertEquals(float, type(text_format._INFINITY))
  497. self.assertEquals(float, type(text_format._NAN))
  498. self.assertTrue(text_format._NAN != text_format._NAN)
  499. inf_times_zero = text_format._INFINITY * 0
  500. self.assertTrue(inf_times_zero != inf_times_zero)
  501. self.assertTrue(text_format._INFINITY > 0)
  502. if __name__ == '__main__':
  503. unittest.main()