← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/python/google/protobuf/internal/text_format_test.py

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
protobuf/files/python/google/protobuf/internal/text_format_test.py
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
 
 
33
 
"""Test for google.protobuf.text_format."""
34
 
 
35
 
__author__ = 'kenton@google.com (Kenton Varda)'
36
 
 
37
 
import difflib
38
 
 
39
 
import unittest
40
 
from google.protobuf import text_format
41
 
from google.protobuf.internal import test_util
42
 
from google.protobuf import unittest_pb2
43
 
from google.protobuf import unittest_mset_pb2
44
 
 
45
 
 
46
 
class TextFormatTest(unittest.TestCase):
47
 
  def ReadGolden(self, golden_filename):
48
 
    f = test_util.GoldenFile(golden_filename)
49
 
    golden_lines = f.readlines()
50
 
    f.close()
51
 
    return golden_lines
52
 
 
53
 
  def CompareToGoldenFile(self, text, golden_filename):
54
 
    golden_lines = self.ReadGolden(golden_filename)
55
 
    self.CompareToGoldenLines(text, golden_lines)
56
 
 
57
 
  def CompareToGoldenText(self, text, golden_text):
58
 
    self.CompareToGoldenLines(text, golden_text.splitlines(1))
59
 
 
60
 
  def CompareToGoldenLines(self, text, golden_lines):
61
 
    actual_lines = text.splitlines(1)
62
 
    self.assertEqual(golden_lines, actual_lines,
63
 
      "Text doesn't match golden.  Diff:\n" +
64
 
      ''.join(difflib.ndiff(golden_lines, actual_lines)))
65
 
 
66
 
  def testPrintAllFields(self):
67
 
    message = unittest_pb2.TestAllTypes()
68
 
    test_util.SetAllFields(message)
69
 
    self.CompareToGoldenFile(
70
 
      self.RemoveRedundantZeros(text_format.MessageToString(message)),
71
 
      'text_format_unittest_data.txt')
72
 
 
73
 
  def testPrintAllExtensions(self):
74
 
    message = unittest_pb2.TestAllExtensions()
75
 
    test_util.SetAllExtensions(message)
76
 
    self.CompareToGoldenFile(
77
 
      self.RemoveRedundantZeros(text_format.MessageToString(message)),
78
 
      'text_format_unittest_extensions_data.txt')
79
 
 
80
 
  def testPrintMessageSet(self):
81
 
    message = unittest_mset_pb2.TestMessageSetContainer()
82
 
    ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
83
 
    ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
84
 
    message.message_set.Extensions[ext1].i = 23
85
 
    message.message_set.Extensions[ext2].str = 'foo'
86
 
    self.CompareToGoldenText(text_format.MessageToString(message),
87
 
      'message_set {\n'
88
 
      '  [protobuf_unittest.TestMessageSetExtension1] {\n'
89
 
      '    i: 23\n'
90
 
      '  }\n'
91
 
      '  [protobuf_unittest.TestMessageSetExtension2] {\n'
92
 
      '    str: \"foo\"\n'
93
 
      '  }\n'
94
 
      '}\n')
95
 
 
96
 
  def testPrintExotic(self):
97
 
    message = unittest_pb2.TestAllTypes()
98
 
    message.repeated_int64.append(-9223372036854775808);
99
 
    message.repeated_uint64.append(18446744073709551615);
100
 
    message.repeated_double.append(123.456);
101
 
    message.repeated_double.append(1.23e22);
102
 
    message.repeated_double.append(1.23e-18);
103
 
    message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'\"');
104
 
    self.CompareToGoldenText(
105
 
      self.RemoveRedundantZeros(text_format.MessageToString(message)),
106
 
      'repeated_int64: -9223372036854775808\n'
107
 
      'repeated_uint64: 18446744073709551615\n'
108
 
      'repeated_double: 123.456\n'
109
 
      'repeated_double: 1.23e+22\n'
110
 
      'repeated_double: 1.23e-18\n'
111
 
      'repeated_string: '
112
 
        '\"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\\"\"\n')
113
 
 
114
 
  def testMessageToString(self):
115
 
    message = unittest_pb2.ForeignMessage()
116
 
    message.c = 123
117
 
    self.assertEqual('c: 123\n', str(message))
118
 
 
119
 
  def RemoveRedundantZeros(self, text):
120
 
    # Some platforms print 1e+5 as 1e+005.  This is fine, but we need to remove
121
 
    # these zeros in order to match the golden file.
122
 
    return text.replace('e+0','e+').replace('e+0','e+') \
123
 
               .replace('e-0','e-').replace('e-0','e-')
124
 
 
125
 
  def testMergeGolden(self):
126
 
    golden_text = '\n'.join(self.ReadGolden('text_format_unittest_data.txt'))
127
 
    parsed_message = unittest_pb2.TestAllTypes()
128
 
    text_format.Merge(golden_text, parsed_message)
129
 
 
130
 
    message = unittest_pb2.TestAllTypes()
131
 
    test_util.SetAllFields(message)
132
 
    self.assertEquals(message, parsed_message)
133
 
 
134
 
  def testMergeGoldenExtensions(self):
135
 
    golden_text = '\n'.join(self.ReadGolden(
136
 
        'text_format_unittest_extensions_data.txt'))
137
 
    parsed_message = unittest_pb2.TestAllExtensions()
138
 
    text_format.Merge(golden_text, parsed_message)
139
 
 
140
 
    message = unittest_pb2.TestAllExtensions()
141
 
    test_util.SetAllExtensions(message)
142
 
    self.assertEquals(message, parsed_message)
143
 
 
144
 
  def testMergeAllFields(self):
145
 
    message = unittest_pb2.TestAllTypes()
146
 
    test_util.SetAllFields(message)
147
 
    ascii_text = text_format.MessageToString(message)
148
 
 
149
 
    parsed_message = unittest_pb2.TestAllTypes()
150
 
    text_format.Merge(ascii_text, parsed_message)
151
 
    self.assertEqual(message, parsed_message)
152
 
    test_util.ExpectAllFieldsSet(self, message)
153
 
 
154
 
  def testMergeAllExtensions(self):
155
 
    message = unittest_pb2.TestAllExtensions()
156
 
    test_util.SetAllExtensions(message)
157
 
    ascii_text = text_format.MessageToString(message)
158
 
 
159
 
    parsed_message = unittest_pb2.TestAllExtensions()
160
 
    text_format.Merge(ascii_text, parsed_message)
161
 
    self.assertEqual(message, parsed_message)
162
 
 
163
 
  def testMergeMessageSet(self):
164
 
    message = unittest_pb2.TestAllTypes()
165
 
    text = ('repeated_uint64: 1\n'
166
 
            'repeated_uint64: 2\n')
167
 
    text_format.Merge(text, message)
168
 
    self.assertEqual(1, message.repeated_uint64[0])
169
 
    self.assertEqual(2, message.repeated_uint64[1])
170
 
 
171
 
    message = unittest_mset_pb2.TestMessageSetContainer()
172
 
    text = ('message_set {\n'
173
 
            '  [protobuf_unittest.TestMessageSetExtension1] {\n'
174
 
            '    i: 23\n'
175
 
            '  }\n'
176
 
            '  [protobuf_unittest.TestMessageSetExtension2] {\n'
177
 
            '    str: \"foo\"\n'
178
 
            '  }\n'
179
 
            '}\n')
180
 
    text_format.Merge(text, message)
181
 
    ext1 = unittest_mset_pb2.TestMessageSetExtension1.message_set_extension
182
 
    ext2 = unittest_mset_pb2.TestMessageSetExtension2.message_set_extension
183
 
    self.assertEquals(23, message.message_set.Extensions[ext1].i)
184
 
    self.assertEquals('foo', message.message_set.Extensions[ext2].str)
185
 
 
186
 
  def testMergeExotic(self):
187
 
    message = unittest_pb2.TestAllTypes()
188
 
    text = ('repeated_int64: -9223372036854775808\n'
189
 
            'repeated_uint64: 18446744073709551615\n'
190
 
            'repeated_double: 123.456\n'
191
 
            'repeated_double: 1.23e+22\n'
192
 
            'repeated_double: 1.23e-18\n'
193
 
            'repeated_string: \n'
194
 
            '\"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\\"\"\n'
195
 
            'repeated_string: "foo" \'corge\' "grault"')
196
 
    text_format.Merge(text, message)
197
 
 
198
 
    self.assertEqual(-9223372036854775808, message.repeated_int64[0])
199
 
    self.assertEqual(18446744073709551615, message.repeated_uint64[0])
200
 
    self.assertEqual(123.456, message.repeated_double[0])
201
 
    self.assertEqual(1.23e22, message.repeated_double[1])
202
 
    self.assertEqual(1.23e-18, message.repeated_double[2])
203
 
    self.assertEqual(
204
 
        '\000\001\a\b\f\n\r\t\v\\\'\"', message.repeated_string[0])
205
 
    self.assertEqual('foocorgegrault', message.repeated_string[1])
206
 
 
207
 
  def testMergeUnknownField(self):
208
 
    message = unittest_pb2.TestAllTypes()
209
 
    text = 'unknown_field: 8\n'
210
 
    self.assertRaisesWithMessage(
211
 
        text_format.ParseError,
212
 
        ('1:1 : Message type "protobuf_unittest.TestAllTypes" has no field named '
213
 
         '"unknown_field".'),
214
 
        text_format.Merge, text, message)
215
 
 
216
 
  def testMergeBadExtension(self):
217
 
    message = unittest_pb2.TestAllExtensions()
218
 
    text = '[unknown_extension]: 8\n'
219
 
    self.assertRaisesWithMessage(
220
 
        text_format.ParseError,
221
 
        '1:2 : Extension "unknown_extension" not registered.',
222
 
        text_format.Merge, text, message)
223
 
    message = unittest_pb2.TestAllTypes()
224
 
    self.assertRaisesWithMessage(
225
 
        text_format.ParseError,
226
 
        ('1:2 : Message type "protobuf_unittest.TestAllTypes" does not have '
227
 
         'extensions.'),
228
 
        text_format.Merge, text, message)
229
 
 
230
 
  def testMergeGroupNotClosed(self):
231
 
    message = unittest_pb2.TestAllTypes()
232
 
    text = 'RepeatedGroup: <'
233
 
    self.assertRaisesWithMessage(
234
 
        text_format.ParseError, '1:16 : Expected ">".',
235
 
        text_format.Merge, text, message)
236
 
 
237
 
    text = 'RepeatedGroup: {'
238
 
    self.assertRaisesWithMessage(
239
 
        text_format.ParseError, '1:16 : Expected "}".',
240
 
        text_format.Merge, text, message)
241
 
 
242
 
  def testMergeEmptyGroup(self):
243
 
    message = unittest_pb2.TestAllTypes()
244
 
    text = 'OptionalGroup: {}'
245
 
    text_format.Merge(text, message)
246
 
    self.assertTrue(message.HasField('optionalgroup'))
247
 
 
248
 
    message.Clear()
249
 
 
250
 
    message = unittest_pb2.TestAllTypes()
251
 
    text = 'OptionalGroup: <>'
252
 
    text_format.Merge(text, message)
253
 
    self.assertTrue(message.HasField('optionalgroup'))
254
 
 
255
 
  def testMergeBadEnumValue(self):
256
 
    message = unittest_pb2.TestAllTypes()
257
 
    text = 'optional_nested_enum: BARR'
258
 
    self.assertRaisesWithMessage(
259
 
        text_format.ParseError,
260
 
        ('1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
261
 
         'has no value named BARR.'),
262
 
        text_format.Merge, text, message)
263
 
 
264
 
    message = unittest_pb2.TestAllTypes()
265
 
    text = 'optional_nested_enum: 100'
266
 
    self.assertRaisesWithMessage(
267
 
        text_format.ParseError,
268
 
        ('1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
269
 
         'has no value with number 100.'),
270
 
        text_format.Merge, text, message)
271
 
 
272
 
  def assertRaisesWithMessage(self, e_class, e, func, *args, **kwargs):
273
 
    """Same as assertRaises, but also compares the exception message."""
274
 
    if hasattr(e_class, '__name__'):
275
 
      exc_name = e_class.__name__
276
 
    else:
277
 
      exc_name = str(e_class)
278
 
 
279
 
    try:
280
 
      func(*args, **kwargs)
281
 
    except e_class, expr:
282
 
      if str(expr) != e:
283
 
        msg = '%s raised, but with wrong message: "%s" instead of "%s"'
284
 
        raise self.failureException(msg % (exc_name,
285
 
                                           str(expr).encode('string_escape'),
286
 
                                           e.encode('string_escape')))
287
 
      return
288
 
    else:
289
 
      raise self.failureException('%s not raised' % exc_name)
290
 
 
291
 
 
292
 
class TokenizerTest(unittest.TestCase):
293
 
 
294
 
  def testSimpleTokenCases(self):
295
 
    text = ('identifier1:"string1"\n     \n\n'
296
 
            'identifier2 : \n \n123  \n  identifier3 :\'string\'\n'
297
 
            'identifiER_4 : 1.1e+2 ID5:-0.23 ID6:\'aaaa\\\'bbbb\'\n'
298
 
            'ID7 : "aa\\"bb"\n\n\n\n ID8: {A:inf B:-inf C:true D:false}\n'
299
 
            'ID9: 22 ID10: -111111111111111111 ID11: -22\n'
300
 
            'ID12: 2222222222222222222')
301
 
    tokenizer = text_format._Tokenizer(text)
302
 
    methods = [(tokenizer.ConsumeIdentifier, 'identifier1'),
303
 
               ':',
304
 
               (tokenizer.ConsumeString, 'string1'),
305
 
               (tokenizer.ConsumeIdentifier, 'identifier2'),
306
 
               ':',
307
 
               (tokenizer.ConsumeInt32, 123),
308
 
               (tokenizer.ConsumeIdentifier, 'identifier3'),
309
 
               ':',
310
 
               (tokenizer.ConsumeString, 'string'),
311
 
               (tokenizer.ConsumeIdentifier, 'identifiER_4'),
312
 
               ':',
313
 
               (tokenizer.ConsumeFloat, 1.1e+2),
314
 
               (tokenizer.ConsumeIdentifier, 'ID5'),
315
 
               ':',
316
 
               (tokenizer.ConsumeFloat, -0.23),
317
 
               (tokenizer.ConsumeIdentifier, 'ID6'),
318
 
               ':',
319
 
               (tokenizer.ConsumeString, 'aaaa\'bbbb'),
320
 
               (tokenizer.ConsumeIdentifier, 'ID7'),
321
 
               ':',
322
 
               (tokenizer.ConsumeString, 'aa\"bb'),
323
 
               (tokenizer.ConsumeIdentifier, 'ID8'),
324
 
               ':',
325
 
               '{',
326
 
               (tokenizer.ConsumeIdentifier, 'A'),
327
 
               ':',
328
 
               (tokenizer.ConsumeFloat, text_format._INFINITY),
329
 
               (tokenizer.ConsumeIdentifier, 'B'),
330
 
               ':',
331
 
               (tokenizer.ConsumeFloat, -text_format._INFINITY),
332
 
               (tokenizer.ConsumeIdentifier, 'C'),
333
 
               ':',
334
 
               (tokenizer.ConsumeBool, True),
335
 
               (tokenizer.ConsumeIdentifier, 'D'),
336
 
               ':',
337
 
               (tokenizer.ConsumeBool, False),
338
 
               '}',
339
 
               (tokenizer.ConsumeIdentifier, 'ID9'),
340
 
               ':',
341
 
               (tokenizer.ConsumeUint32, 22),
342
 
               (tokenizer.ConsumeIdentifier, 'ID10'),
343
 
               ':',
344
 
               (tokenizer.ConsumeInt64, -111111111111111111),
345
 
               (tokenizer.ConsumeIdentifier, 'ID11'),
346
 
               ':',
347
 
               (tokenizer.ConsumeInt32, -22),
348
 
               (tokenizer.ConsumeIdentifier, 'ID12'),
349
 
               ':',
350
 
               (tokenizer.ConsumeUint64, 2222222222222222222)]
351
 
 
352
 
    i = 0
353
 
    while not tokenizer.AtEnd():
354
 
      m = methods[i]
355
 
      if type(m) == str:
356
 
        token = tokenizer.token
357
 
        self.assertEqual(token, m)
358
 
        tokenizer.NextToken()
359
 
      else:
360
 
        self.assertEqual(m[1], m[0]())
361
 
      i += 1
362
 
 
363
 
  def testConsumeIntegers(self):
364
 
    # This test only tests the failures in the integer parsing methods as well
365
 
    # as the '0' special cases.
366
 
    int64_max = (1 << 63) - 1
367
 
    uint32_max = (1 << 32) - 1
368
 
    text = '-1 %d %d' % (uint32_max + 1, int64_max + 1)
369
 
    tokenizer = text_format._Tokenizer(text)
370
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
371
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint64)
372
 
    self.assertEqual(-1, tokenizer.ConsumeInt32())
373
 
 
374
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
375
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt32)
376
 
    self.assertEqual(uint32_max + 1, tokenizer.ConsumeInt64())
377
 
 
378
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt64)
379
 
    self.assertEqual(int64_max + 1, tokenizer.ConsumeUint64())
380
 
    self.assertTrue(tokenizer.AtEnd())
381
 
 
382
 
    text = '-0 -0 0 0'
383
 
    tokenizer = text_format._Tokenizer(text)
384
 
    self.assertEqual(0, tokenizer.ConsumeUint32())
385
 
    self.assertEqual(0, tokenizer.ConsumeUint64())
386
 
    self.assertEqual(0, tokenizer.ConsumeUint32())
387
 
    self.assertEqual(0, tokenizer.ConsumeUint64())
388
 
    self.assertTrue(tokenizer.AtEnd())
389
 
 
390
 
  def testConsumeByteString(self):
391
 
    text = '"string1\''
392
 
    tokenizer = text_format._Tokenizer(text)
393
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
394
 
 
395
 
    text = 'string1"'
396
 
    tokenizer = text_format._Tokenizer(text)
397
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
398
 
 
399
 
    text = '\n"\\xt"'
400
 
    tokenizer = text_format._Tokenizer(text)
401
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
402
 
 
403
 
    text = '\n"\\"'
404
 
    tokenizer = text_format._Tokenizer(text)
405
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
406
 
 
407
 
    text = '\n"\\x"'
408
 
    tokenizer = text_format._Tokenizer(text)
409
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeByteString)
410
 
 
411
 
  def testConsumeBool(self):
412
 
    text = 'not-a-bool'
413
 
    tokenizer = text_format._Tokenizer(text)
414
 
    self.assertRaises(text_format.ParseError, tokenizer.ConsumeBool)
415
 
 
416
 
  def testInfNan(self):
417
 
    # Make sure our infinity and NaN definitions are sound.
418
 
    self.assertEquals(float, type(text_format._INFINITY))
419
 
    self.assertEquals(float, type(text_format._NAN))
420
 
    self.assertTrue(text_format._NAN != text_format._NAN)
421
 
 
422
 
    inf_times_zero = text_format._INFINITY * 0
423
 
    self.assertTrue(inf_times_zero != inf_times_zero)
424
 
    self.assertTrue(text_format._INFINITY > 0)
425
 
 
426
 
 
427
 
if __name__ == '__main__':
428
 
  unittest.main()