src/third_party/protobuf/python/google/protobuf/internal/wire_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.internal.wire_format."""
  34
  35 __author__ = 'robinson@google.com (Will Robinson)'
  36
  37 import unittest
  38 from google.protobuf import message
  39 from google.protobuf.internal import wire_format
  40
  41
  42 class 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
 252 if __name__ == '__main__':
 253   unittest.main()