PageRenderTime 140ms CodeModel.GetById 90ms app.highlight 46ms RepoModel.GetById 1ms app.codeStats 0ms

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

http://github.com/tomahawk-player/tomahawk
Python | 253 lines | 155 code | 26 blank | 72 comment | 11 complexity | 9631d9090165366dafed6011cebc9ff8 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
 33"""Test for google.protobuf.internal.wire_format."""
 34
 35__author__ = 'robinson@google.com (Will Robinson)'
 36
 37import unittest
 38from google.protobuf import message
 39from google.protobuf.internal import wire_format
 40
 41
 42class WireFormatTest(unittest.TestCase):
 43
 44  def testPackTag(self):
 45    field_number = 0xabc
 46    tag_type = 2
 47    self.assertEqual((field_number << 3) | tag_type,
 48                     wire_format.PackTag(field_number, tag_type))
 49    PackTag = wire_format.PackTag
 50    # Number too high.
 51    self.assertRaises(message.EncodeError, PackTag, field_number, 6)
 52    # Number too low.
 53    self.assertRaises(message.EncodeError, PackTag, field_number, -1)
 54
 55  def testUnpackTag(self):
 56    # Test field numbers that will require various varint sizes.
 57    for expected_field_number in (1, 15, 16, 2047, 2048):
 58      for expected_wire_type in range(6):  # Highest-numbered wiretype is 5.
 59        field_number, wire_type = wire_format.UnpackTag(
 60            wire_format.PackTag(expected_field_number, expected_wire_type))
 61        self.assertEqual(expected_field_number, field_number)
 62        self.assertEqual(expected_wire_type, wire_type)
 63
 64    self.assertRaises(TypeError, wire_format.UnpackTag, None)
 65    self.assertRaises(TypeError, wire_format.UnpackTag, 'abc')
 66    self.assertRaises(TypeError, wire_format.UnpackTag, 0.0)
 67    self.assertRaises(TypeError, wire_format.UnpackTag, object())
 68
 69  def testZigZagEncode(self):
 70    Z = wire_format.ZigZagEncode
 71    self.assertEqual(0, Z(0))
 72    self.assertEqual(1, Z(-1))
 73    self.assertEqual(2, Z(1))
 74    self.assertEqual(3, Z(-2))
 75    self.assertEqual(4, Z(2))
 76    self.assertEqual(0xfffffffe, Z(0x7fffffff))
 77    self.assertEqual(0xffffffff, Z(-0x80000000))
 78    self.assertEqual(0xfffffffffffffffe, Z(0x7fffffffffffffff))
 79    self.assertEqual(0xffffffffffffffff, Z(-0x8000000000000000))
 80
 81    self.assertRaises(TypeError, Z, None)
 82    self.assertRaises(TypeError, Z, 'abcd')
 83    self.assertRaises(TypeError, Z, 0.0)
 84    self.assertRaises(TypeError, Z, object())
 85
 86  def testZigZagDecode(self):
 87    Z = wire_format.ZigZagDecode
 88    self.assertEqual(0, Z(0))
 89    self.assertEqual(-1, Z(1))
 90    self.assertEqual(1, Z(2))
 91    self.assertEqual(-2, Z(3))
 92    self.assertEqual(2, Z(4))
 93    self.assertEqual(0x7fffffff, Z(0xfffffffe))
 94    self.assertEqual(-0x80000000, Z(0xffffffff))
 95    self.assertEqual(0x7fffffffffffffff, Z(0xfffffffffffffffe))
 96    self.assertEqual(-0x8000000000000000, Z(0xffffffffffffffff))
 97
 98    self.assertRaises(TypeError, Z, None)
 99    self.assertRaises(TypeError, Z, 'abcd')
100    self.assertRaises(TypeError, Z, 0.0)
101    self.assertRaises(TypeError, Z, object())
102
103  def NumericByteSizeTestHelper(self, byte_size_fn, value, expected_value_size):
104    # Use field numbers that cause various byte sizes for the tag information.
105    for field_number, tag_bytes in ((15, 1), (16, 2), (2047, 2), (2048, 3)):
106      expected_size = expected_value_size + tag_bytes
107      actual_size = byte_size_fn(field_number, value)
108      self.assertEqual(expected_size, actual_size,
109                       'byte_size_fn: %s, field_number: %d, value: %r\n'
110                       'Expected: %d, Actual: %d'% (
111          byte_size_fn, field_number, value, expected_size, actual_size))
112
113  def testByteSizeFunctions(self):
114    # Test all numeric *ByteSize() functions.
115    NUMERIC_ARGS = [
116        # Int32ByteSize().
117        [wire_format.Int32ByteSize, 0, 1],
118        [wire_format.Int32ByteSize, 127, 1],
119        [wire_format.Int32ByteSize, 128, 2],
120        [wire_format.Int32ByteSize, -1, 10],
121        # Int64ByteSize().
122        [wire_format.Int64ByteSize, 0, 1],
123        [wire_format.Int64ByteSize, 127, 1],
124        [wire_format.Int64ByteSize, 128, 2],
125        [wire_format.Int64ByteSize, -1, 10],
126        # UInt32ByteSize().
127        [wire_format.UInt32ByteSize, 0, 1],
128        [wire_format.UInt32ByteSize, 127, 1],
129        [wire_format.UInt32ByteSize, 128, 2],
130        [wire_format.UInt32ByteSize, wire_format.UINT32_MAX, 5],
131        # UInt64ByteSize().
132        [wire_format.UInt64ByteSize, 0, 1],
133        [wire_format.UInt64ByteSize, 127, 1],
134        [wire_format.UInt64ByteSize, 128, 2],
135        [wire_format.UInt64ByteSize, wire_format.UINT64_MAX, 10],
136        # SInt32ByteSize().
137        [wire_format.SInt32ByteSize, 0, 1],
138        [wire_format.SInt32ByteSize, -1, 1],
139        [wire_format.SInt32ByteSize, 1, 1],
140        [wire_format.SInt32ByteSize, -63, 1],
141        [wire_format.SInt32ByteSize, 63, 1],
142        [wire_format.SInt32ByteSize, -64, 1],
143        [wire_format.SInt32ByteSize, 64, 2],
144        # SInt64ByteSize().
145        [wire_format.SInt64ByteSize, 0, 1],
146        [wire_format.SInt64ByteSize, -1, 1],
147        [wire_format.SInt64ByteSize, 1, 1],
148        [wire_format.SInt64ByteSize, -63, 1],
149        [wire_format.SInt64ByteSize, 63, 1],
150        [wire_format.SInt64ByteSize, -64, 1],
151        [wire_format.SInt64ByteSize, 64, 2],
152        # Fixed32ByteSize().
153        [wire_format.Fixed32ByteSize, 0, 4],
154        [wire_format.Fixed32ByteSize, wire_format.UINT32_MAX, 4],
155        # Fixed64ByteSize().
156        [wire_format.Fixed64ByteSize, 0, 8],
157        [wire_format.Fixed64ByteSize, wire_format.UINT64_MAX, 8],
158        # SFixed32ByteSize().
159        [wire_format.SFixed32ByteSize, 0, 4],
160        [wire_format.SFixed32ByteSize, wire_format.INT32_MIN, 4],
161        [wire_format.SFixed32ByteSize, wire_format.INT32_MAX, 4],
162        # SFixed64ByteSize().
163        [wire_format.SFixed64ByteSize, 0, 8],
164        [wire_format.SFixed64ByteSize, wire_format.INT64_MIN, 8],
165        [wire_format.SFixed64ByteSize, wire_format.INT64_MAX, 8],
166        # FloatByteSize().
167        [wire_format.FloatByteSize, 0.0, 4],
168        [wire_format.FloatByteSize, 1000000000.0, 4],
169        [wire_format.FloatByteSize, -1000000000.0, 4],
170        # DoubleByteSize().
171        [wire_format.DoubleByteSize, 0.0, 8],
172        [wire_format.DoubleByteSize, 1000000000.0, 8],
173        [wire_format.DoubleByteSize, -1000000000.0, 8],
174        # BoolByteSize().
175        [wire_format.BoolByteSize, False, 1],
176        [wire_format.BoolByteSize, True, 1],
177        # EnumByteSize().
178        [wire_format.EnumByteSize, 0, 1],
179        [wire_format.EnumByteSize, 127, 1],
180        [wire_format.EnumByteSize, 128, 2],
181        [wire_format.EnumByteSize, wire_format.UINT32_MAX, 5],
182        ]
183    for args in NUMERIC_ARGS:
184      self.NumericByteSizeTestHelper(*args)
185
186    # Test strings and bytes.
187    for byte_size_fn in (wire_format.StringByteSize, wire_format.BytesByteSize):
188      # 1 byte for tag, 1 byte for length, 3 bytes for contents.
189      self.assertEqual(5, byte_size_fn(10, 'abc'))
190      # 2 bytes for tag, 1 byte for length, 3 bytes for contents.
191      self.assertEqual(6, byte_size_fn(16, 'abc'))
192      # 2 bytes for tag, 2 bytes for length, 128 bytes for contents.
193      self.assertEqual(132, byte_size_fn(16, 'a' * 128))
194
195    # Test UTF-8 string byte size calculation.
196    # 1 byte for tag, 1 byte for length, 8 bytes for content.
197    self.assertEqual(10, wire_format.StringByteSize(
198        5, unicode('\xd0\xa2\xd0\xb5\xd1\x81\xd1\x82', 'utf-8')))
199
200    class MockMessage(object):
201      def __init__(self, byte_size):
202        self.byte_size = byte_size
203      def ByteSize(self):
204        return self.byte_size
205
206    message_byte_size = 10
207    mock_message = MockMessage(byte_size=message_byte_size)
208    # Test groups.
209    # (2 * 1) bytes for begin and end tags, plus message_byte_size.
210    self.assertEqual(2 + message_byte_size,
211                     wire_format.GroupByteSize(1, mock_message))
212    # (2 * 2) bytes for begin and end tags, plus message_byte_size.
213    self.assertEqual(4 + message_byte_size,
214                     wire_format.GroupByteSize(16, mock_message))
215
216    # Test messages.
217    # 1 byte for tag, plus 1 byte for length, plus contents.
218    self.assertEqual(2 + mock_message.byte_size,
219                     wire_format.MessageByteSize(1, mock_message))
220    # 2 bytes for tag, plus 1 byte for length, plus contents.
221    self.assertEqual(3 + mock_message.byte_size,
222                     wire_format.MessageByteSize(16, mock_message))
223    # 2 bytes for tag, plus 2 bytes for length, plus contents.
224    mock_message.byte_size = 128
225    self.assertEqual(4 + mock_message.byte_size,
226                     wire_format.MessageByteSize(16, mock_message))
227
228
229    # Test message set item byte size.
230    # 4 bytes for tags, plus 1 byte for length, plus 1 byte for type_id,
231    # plus contents.
232    mock_message.byte_size = 10
233    self.assertEqual(mock_message.byte_size + 6,
234                     wire_format.MessageSetItemByteSize(1, mock_message))
235
236    # 4 bytes for tags, plus 2 bytes for length, plus 1 byte for type_id,
237    # plus contents.
238    mock_message.byte_size = 128
239    self.assertEqual(mock_message.byte_size + 7,
240                     wire_format.MessageSetItemByteSize(1, mock_message))
241
242    # 4 bytes for tags, plus 2 bytes for length, plus 2 byte for type_id,
243    # plus contents.
244    self.assertEqual(mock_message.byte_size + 8,
245                     wire_format.MessageSetItemByteSize(128, mock_message))
246
247    # Too-long varint.
248    self.assertRaises(message.EncodeError,
249                      wire_format.UInt64ByteSize, 1, 1 << 128)
250
251
252if __name__ == '__main__':
253  unittest.main()