1b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer#! /usr/bin/env python 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# -*- coding: utf-8 -*- 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# Protocol Buffers - Google's data interchange format 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# Copyright 2008 Google Inc. All rights reserved. 6afb4b72037e3f13db208590fc782c4bc8e27f862Jeff Davidson# https://developers.google.com/protocol-buffers/ 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# Redistribution and use in source and binary forms, with or without 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# modification, are permitted provided that the following conditions are 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# met: 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Redistributions of source code must retain the above copyright 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# notice, this list of conditions and the following disclaimer. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Redistributions in binary form must reproduce the above 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# copyright notice, this list of conditions and the following disclaimer 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# in the documentation and/or other materials provided with the 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# distribution. 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Neither the name of Google Inc. nor the names of its 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# contributors may be used to endorse or promote products derived from 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# this software without specific prior written permission. 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville"""Unittest for reflection.py, which also indirectly tests the output of the 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillepure-Python protocol compiler. 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville""" 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 38a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonimport copy 39a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonimport gc 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleimport operator 41b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerimport six 42d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleimport struct 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 44b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammertry: 45b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer import unittest2 as unittest #PY26 46b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerexcept ImportError: 47b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer import unittest 48b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import unittest_import_pb2 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import unittest_mset_pb2 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import unittest_pb2 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import descriptor_pb2 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import descriptor 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import message 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf import reflection 56a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonfrom google.protobuf import text_format 57a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonfrom google.protobuf.internal import api_implementation 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf.internal import more_extensions_pb2 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf.internal import more_messages_pb2 60b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerfrom google.protobuf.internal import message_set_extensions_pb2 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf.internal import wire_format 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf.internal import test_util 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillefrom google.protobuf.internal import decoder 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 66d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Savilleclass _MiniDecoder(object): 67d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville """Decodes a stream of values from a string. 68d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 69d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville Once upon a time we actually had a class called decoder.Decoder. Then we 70d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville got rid of it during a redesign that made decoding much, much faster overall. 71d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville But a couple tests in this file used it to check that the serialized form of 72d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville a message was correct. So, this class implements just the methods that were 73d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville used by said tests, so that we don't have to rewrite the tests. 74d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville """ 75d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 76d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def __init__(self, bytes): 77d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._bytes = bytes 78d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._pos = 0 79d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 80d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def ReadVarint(self): 81d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville result, self._pos = decoder._DecodeVarint(self._bytes, self._pos) 82d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return result 83d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 84d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ReadInt32 = ReadVarint 85d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ReadInt64 = ReadVarint 86d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ReadUInt32 = ReadVarint 87d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ReadUInt64 = ReadVarint 88d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 89d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def ReadSInt64(self): 90d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return wire_format.ZigZagDecode(self.ReadVarint()) 91d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 92d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville ReadSInt32 = ReadSInt64 93d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 94d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def ReadFieldNumberAndWireType(self): 95d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return wire_format.UnpackTag(self.ReadVarint()) 96d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 97d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def ReadFloat(self): 98d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville result = struct.unpack("<f", self._bytes[self._pos:self._pos+4])[0] 99d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._pos += 4 100d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return result 101d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 102d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def ReadDouble(self): 103d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville result = struct.unpack("<d", self._bytes[self._pos:self._pos+8])[0] 104d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._pos += 8 105d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return result 106d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 107d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def EndOfStream(self): 108d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville return self._pos == len(self._bytes) 109d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 110d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 111b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass ReflectionTest(unittest.TestCase): 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 113a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def assertListsEqual(self, values, others): 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(len(values), len(others)) 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for i in range(len(values)): 116a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(values[i], others[i]) 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 118d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testScalarConstructor(self): 119d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Constructor with only scalar types should succeed. 120d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes( 121d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville optional_int32=24, 122d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville optional_double=54.321, 123b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer optional_string='optional_string', 124b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer optional_float=None) 125d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 126d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(24, proto.optional_int32) 127d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(54.321, proto.optional_double) 128d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual('optional_string', proto.optional_string) 129b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertFalse(proto.HasField("optional_float")) 130d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 131d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testRepeatedScalarConstructor(self): 132d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Constructor with only repeated scalar types should succeed. 133d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes( 134d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_int32=[1, 2, 3, 4], 135d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_double=[1.23, 54.321], 136d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_bool=[True, False, False], 137b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer repeated_string=["optional_string"], 138b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer repeated_float=None) 139d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 140b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([1, 2, 3, 4], list(proto.repeated_int32)) 141b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([1.23, 54.321], list(proto.repeated_double)) 142b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([True, False, False], list(proto.repeated_bool)) 143b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(["optional_string"], list(proto.repeated_string)) 144b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([], list(proto.repeated_float)) 145d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 146d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testRepeatedCompositeConstructor(self): 147d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Constructor with only repeated composite types should succeed. 148d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes( 149d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_nested_message=[ 150d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 151d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.FOO), 152d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 153d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.BAR)], 154d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_foreign_message=[ 155d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=-43), 156d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=45324), 157d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=12)], 158d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeatedgroup=[ 159d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.RepeatedGroup(), 160d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.RepeatedGroup(a=1), 161d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.RepeatedGroup(a=2)]) 162d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 163b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 164d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [unittest_pb2.TestAllTypes.NestedMessage( 165d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.FOO), 166d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 167d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.BAR)], 168d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville list(proto.repeated_nested_message)) 169b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 170d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [unittest_pb2.ForeignMessage(c=-43), 171d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=45324), 172d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=12)], 173d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville list(proto.repeated_foreign_message)) 174b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 175d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [unittest_pb2.TestAllTypes.RepeatedGroup(), 176d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.RepeatedGroup(a=1), 177d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.RepeatedGroup(a=2)], 178d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville list(proto.repeatedgroup)) 179d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 180d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testMixedConstructor(self): 181d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Constructor with only mixed types should succeed. 182d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes( 183d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville optional_int32=24, 184d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville optional_string='optional_string', 185d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_double=[1.23, 54.321], 186d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_bool=[True, False, False], 187d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_nested_message=[ 188d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 189d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.FOO), 190d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 191d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.BAR)], 192d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville repeated_foreign_message=[ 193d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=-43), 194d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=45324), 195b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unittest_pb2.ForeignMessage(c=12)], 196b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer optional_nested_message=None) 197d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 198d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(24, proto.optional_int32) 199d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual('optional_string', proto.optional_string) 200b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([1.23, 54.321], list(proto.repeated_double)) 201b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([True, False, False], list(proto.repeated_bool)) 202b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 203d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [unittest_pb2.TestAllTypes.NestedMessage( 204d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.FOO), 205d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage( 206d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville bb=unittest_pb2.TestAllTypes.BAR)], 207d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville list(proto.repeated_nested_message)) 208b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 209d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [unittest_pb2.ForeignMessage(c=-43), 210d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=45324), 211d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.ForeignMessage(c=12)], 212d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville list(proto.repeated_foreign_message)) 213b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertFalse(proto.HasField("optional_nested_message")) 214d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 215a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testConstructorTypeError(self): 216a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 217a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, optional_int32="foo") 218a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 219a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, optional_string=1234) 220a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 221a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, optional_nested_message=1234) 222a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 223a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_int32=1234) 224a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 225a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_int32=["foo"]) 226a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 227a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_string=1234) 228a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 229a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_string=[1234]) 230a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 231a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_nested_message=1234) 232a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises( 233a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TypeError, unittest_pb2.TestAllTypes, repeated_nested_message=[1234]) 234a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 235a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testConstructorInvalidatesCachedByteSize(self): 236a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message = unittest_pb2.TestAllTypes(optional_int32 = 12) 237b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(2, message.ByteSize()) 238a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 239a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message = unittest_pb2.TestAllTypes( 240a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson optional_nested_message = unittest_pb2.TestAllTypes.NestedMessage()) 241b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(3, message.ByteSize()) 242a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 243a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message = unittest_pb2.TestAllTypes(repeated_int32 = [12]) 244b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(3, message.ByteSize()) 245a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 246a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message = unittest_pb2.TestAllTypes( 247a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson repeated_nested_message = [unittest_pb2.TestAllTypes.NestedMessage()]) 248b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(3, message.ByteSize()) 249a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSimpleHasBits(self): 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test a scalar. 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_int32')) 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_int32) 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # HasField() shouldn't be true if all we've done is 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # read the default value. 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_int32')) 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 1 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Setting a value however *should* set the "has" bit. 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_int32')) 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('optional_int32') 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # And clearing that value should unset the "has" bit. 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_int32')) 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHasBitsWithSinglyNestedScalar(self): 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Helper used to test foreign messages and groups. 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # composite_field_name should be the name of a non-repeated 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # composite (i.e., foreign or group) field in TestAllTypes, 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # and scalar_field_name should be the name of an integer-valued 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # scalar field within that composite. 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # I never thought I'd miss C++ macros and templates so much. :( 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # This helper is semantically just: 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert proto.composite_field.scalar_field == 0 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.composite_field.HasField('scalar_field') 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.HasField('composite_field') 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # proto.composite_field.scalar_field = 10 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # old_composite_field = proto.composite_field 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert proto.composite_field.scalar_field == 10 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert proto.composite_field.HasField('scalar_field') 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert proto.HasField('composite_field') 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # proto.ClearField('composite_field') 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.composite_field.HasField('scalar_field') 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.HasField('composite_field') 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert proto.composite_field.scalar_field == 0 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # # Now ensure that ClearField('composite_field') disconnected 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # # the old field object from the object tree... 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert old_composite_field is not proto.composite_field 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # old_composite_field.scalar_field = 20 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.composite_field.HasField('scalar_field') 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # assert not proto.HasField('composite_field') 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def TestCompositeHasBits(composite_field_name, scalar_field_name): 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # First, check that we can get the scalar value, and see that it's the 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # default (0), but that proto.HasField('omposite') and 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # proto.composite.HasField('scalar') will still return False. 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville composite_field = getattr(proto, composite_field_name) 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville original_scalar_value = getattr(composite_field, scalar_field_name) 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, original_scalar_value) 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assert that the composite object does not "have" the scalar. 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not composite_field.HasField(scalar_field_name)) 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assert that proto does not "have" the composite field. 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField(composite_field_name)) 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Now set the scalar within the composite field. Ensure that the setting 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # is reflected, and that proto.HasField('composite') and 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # proto.composite.HasField('scalar') now both return True. 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville new_val = 20 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville setattr(composite_field, scalar_field_name, new_val) 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(new_val, getattr(composite_field, scalar_field_name)) 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Hold on to a reference to the current composite_field object. 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville old_composite_field = composite_field 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assert that the has methods now return true. 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(composite_field.HasField(scalar_field_name)) 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField(composite_field_name)) 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Now call the clear method... 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField(composite_field_name) 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # ...and ensure that the "has" bits are all back to False... 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville composite_field = getattr(proto, composite_field_name) 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not composite_field.HasField(scalar_field_name)) 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField(composite_field_name)) 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # ...and ensure that the scalar field has returned to its default. 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, getattr(composite_field, scalar_field_name)) 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(old_composite_field is not composite_field) 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville setattr(old_composite_field, scalar_field_name, new_val) 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not composite_field.HasField(scalar_field_name)) 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField(composite_field_name)) 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, getattr(composite_field, scalar_field_name)) 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test simple, single-level nesting when we set a scalar. 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCompositeHasBits('optionalgroup', 'a') 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCompositeHasBits('optional_nested_message', 'bb') 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCompositeHasBits('optional_foreign_message', 'c') 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestCompositeHasBits('optional_import_message', 'd') 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testReferencesToNestedMessage(self): 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville nested = proto.optional_nested_message 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del proto 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # A previous version had a bug where this would raise an exception when 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # hitting a now-dead weak reference. 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville nested.bb = 23 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testDisconnectingNestedMessageBeforeSettingField(self): 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville nested = proto.optional_nested_message 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('optional_nested_message') # Should disconnect from parent 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(nested is not proto.optional_nested_message) 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville nested.bb = 23 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_nested_message')) 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_nested_message.bb) 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 363a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testGetDefaultMessageAfterDisconnectingDefaultMessage(self): 364a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 365a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.optional_nested_message 366a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.ClearField('optional_nested_message') 367a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto 368a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del nested 369a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Force a garbage collect so that the underlying CMessages are freed along 370a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # with the Messages they point to. This is to make sure we're not deleting 371a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # default message instances. 372a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson gc.collect() 373a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 374a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.optional_nested_message 375a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 376a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDisconnectingNestedMessageAfterSettingField(self): 377a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 378a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.optional_nested_message 379a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested.bb = 5 380a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(proto.HasField('optional_nested_message')) 381a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.ClearField('optional_nested_message') # Should disconnect from parent 382a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(5, nested.bb) 383a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.optional_nested_message.bb) 384a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(nested is not proto.optional_nested_message) 385a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested.bb = 23 386a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(not proto.HasField('optional_nested_message')) 387a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.optional_nested_message.bb) 388a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 389a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDisconnectingNestedMessageBeforeGettingField(self): 390a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 391a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(not proto.HasField('optional_nested_message')) 392a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.ClearField('optional_nested_message') 393a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(not proto.HasField('optional_nested_message')) 394a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 395a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDisconnectingNestedMessageAfterMerge(self): 396a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # This test exercises the code path that does not use ReleaseMessage(). 397a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # The underlying fear is that if we use ReleaseMessage() incorrectly, 398a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # we will have memory leaks. It's hard to check that that doesn't happen, 399a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # but at least we can exercise that code path to make sure it works. 400a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1 = unittest_pb2.TestAllTypes() 401a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = unittest_pb2.TestAllTypes() 402a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.optional_nested_message.bb = 5 403a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1.MergeFrom(proto2) 404a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(proto1.HasField('optional_nested_message')) 405a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1.ClearField('optional_nested_message') 406a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(not proto1.HasField('optional_nested_message')) 407a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 408a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDisconnectingLazyNestedMessage(self): 409a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # This test exercises releasing a nested message that is lazy. This test 410a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # only exercises real code in the C++ implementation as Python does not 411a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # support lazy parsing, but the current C++ implementation results in 412a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # memory corruption and a crash. 413a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() != 'python': 414a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return 415a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 416a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.optional_lazy_message.bb = 5 417a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.ClearField('optional_lazy_message') 418a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto 419a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson gc.collect() 420a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHasBitsWhenModifyingRepeatedFields(self): 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test nesting when we add an element to a repeated field in a submessage. 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestNestedMessageHasBits() 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_nested_message.nestedmessage_repeated_int32.append(5) 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [5], proto.optional_nested_message.nestedmessage_repeated_int32) 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_nested_message')) 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Do the same test, but with a repeated composite field within the 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # submessage. 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('optional_nested_message') 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_nested_message')) 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_nested_message.nestedmessage_repeated_foreignmessage.add() 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_nested_message')) 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHasBitsForManyLevelsOfNesting(self): 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test nesting many levels deep. 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville recursive_proto = unittest_pb2.TestMutualRecursionA() 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not recursive_proto.HasField('bb')) 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, recursive_proto.bb.a.bb.a.bb.optional_int32) 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not recursive_proto.HasField('bb')) 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville recursive_proto.bb.a.bb.a.bb.optional_int32 = 5 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, recursive_proto.bb.a.bb.a.bb.optional_int32) 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.HasField('bb')) 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.bb.HasField('a')) 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.bb.a.HasField('bb')) 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.bb.a.bb.HasField('a')) 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.bb.a.bb.a.HasField('bb')) 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not recursive_proto.bb.a.bb.a.bb.HasField('a')) 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(recursive_proto.bb.a.bb.a.bb.HasField('optional_int32')) 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingularListFields(self): 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_fixed32 = 1 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 5 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_string = 'foo' 457d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Access sub-message but don't set it yet. 458d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville nested_message = proto.optional_nested_message 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [ (proto.DESCRIPTOR.fields_by_name['optional_int32' ], 5), 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['optional_fixed32'], 1), 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['optional_string' ], 'foo') ], 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ListFields()) 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 465d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_nested_message.bb = 123 466d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual( 467d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville [ (proto.DESCRIPTOR.fields_by_name['optional_int32' ], 5), 468d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville (proto.DESCRIPTOR.fields_by_name['optional_fixed32'], 1), 469d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville (proto.DESCRIPTOR.fields_by_name['optional_string' ], 'foo'), 470d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville (proto.DESCRIPTOR.fields_by_name['optional_nested_message' ], 471d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville nested_message) ], 472d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.ListFields()) 473d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedListFields(self): 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_fixed32.append(1) 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(5) 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(11) 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_string.extend(['foo', 'bar']) 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_string.extend([]) 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_string.append('baz') 482b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.repeated_string.extend(str(x) for x in range(2)) 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 21 484d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_bool # Access but don't set anything; should not be listed. 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [ (proto.DESCRIPTOR.fields_by_name['optional_int32' ], 21), 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['repeated_int32' ], [5, 11]), 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['repeated_fixed32'], [1]), 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['repeated_string' ], 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ['foo', 'bar', 'baz', '0', '1']) ], 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ListFields()) 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingularListExtensions(self): 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.optional_fixed32_extension] = 1 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.optional_int32_extension ] = 5 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.optional_string_extension ] = 'foo' 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [ (unittest_pb2.optional_int32_extension , 5), 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.optional_fixed32_extension, 1), 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.optional_string_extension , 'foo') ], 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ListFields()) 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedListExtensions(self): 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_fixed32_extension].append(1) 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_int32_extension ].append(5) 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_int32_extension ].append(11) 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_string_extension ].append('foo') 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_string_extension ].append('bar') 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.repeated_string_extension ].append('baz') 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[unittest_pb2.optional_int32_extension ] = 21 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [ (unittest_pb2.optional_int32_extension , 21), 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.repeated_int32_extension , [5, 11]), 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.repeated_fixed32_extension, [1]), 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.repeated_string_extension , ['foo', 'bar', 'baz']) ], 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ListFields()) 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testListFieldsAndExtensions(self): 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestFieldOrderings() 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFieldsAndExtensions(proto) 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.my_extension_int 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville [ (proto.DESCRIPTOR.fields_by_name['my_int' ], 1), 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.my_extension_int , 23), 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['my_string'], 'foo'), 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (unittest_pb2.my_extension_string , 'bar'), 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (proto.DESCRIPTOR.fields_by_name['my_float' ], 1.0) ], 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ListFields()) 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testDefaultValues(self): 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_int32) 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_int64) 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_uint32) 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_uint64) 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_sint32) 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_sint64) 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_fixed32) 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_fixed64) 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_sfixed32) 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_sfixed64) 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0.0, proto.optional_float) 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0.0, proto.optional_double) 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(False, proto.optional_bool) 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('', proto.optional_string) 548a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(b'', proto.optional_bytes) 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(41, proto.default_int32) 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(42, proto.default_int64) 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(43, proto.default_uint32) 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(44, proto.default_uint64) 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(-45, proto.default_sint32) 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(46, proto.default_sint64) 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(47, proto.default_fixed32) 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(48, proto.default_fixed64) 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(49, proto.default_sfixed32) 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(-50, proto.default_sfixed64) 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(51.5, proto.default_float) 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(52e3, proto.default_double) 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(True, proto.default_bool) 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('hello', proto.default_string) 564a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(b'world', proto.default_bytes) 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.BAR, proto.default_nested_enum) 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.FOREIGN_BAR, proto.default_foreign_enum) 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_import_pb2.IMPORT_BAR, 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.default_import_enum) 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestExtremeDefaultValues() 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(u'\u1234', proto.utf8_string) 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHasFieldWithUnknownFieldName(self): 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, proto.HasField, 'nonexistent_field') 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testClearFieldWithUnknownFieldName(self): 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, proto.ClearField, 'nonexistent_field') 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 581a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testClearRemovesChildren(self): 582a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Make sure there aren't any implementation bugs that are only partially 583a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # clearing the message (which can happen in the more complex C++ 584a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # implementation which has parallel message lists). 585a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestRequiredForeign() 586a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson for i in range(10): 587a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_message.add() 588a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = unittest_pb2.TestRequiredForeign() 589a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.CopyFrom(proto2) 590a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(IndexError, lambda: proto.repeated_message[5]) 591a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testDisallowedAssignments(self): 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # It's illegal to assign values directly to repeated fields 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # or to nonrepeated composite fields. Ensure that this fails. 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Repeated fields. 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto, 'repeated_int32', 10) 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Lists shouldn't work, either. 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto, 'repeated_int32', [10]) 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Composite fields. 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto, 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 'optional_nested_message', 23) 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assignment to a repeated nested message field without specifying 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # the index in the array of nested messages. 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto.repeated_nested_message, 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 'bb', 34) 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assignment to an attribute of a repeated field. 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto.repeated_float, 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 'some_attribute', 34) 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # proto.nonexistent_field = 23 should fail as well. 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(AttributeError, setattr, proto, 'nonexistent_field', 23) 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingleScalarTypeSafety(self): 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, setattr, proto, 'optional_int32', 1.1) 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, setattr, proto, 'optional_int32', 'foo') 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, setattr, proto, 'optional_string', 10) 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, setattr, proto, 'optional_bytes', 10) 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 620a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testIntegerTypes(self): 621a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def TestGetAndDeserialize(field_name, value, expected_type): 622a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 623a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson setattr(proto, field_name, value) 624b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertIsInstance(getattr(proto, field_name), expected_type) 625a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = unittest_pb2.TestAllTypes() 626a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.ParseFromString(proto.SerializeToString()) 627b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertIsInstance(getattr(proto2, field_name), expected_type) 628a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 629a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TestGetAndDeserialize('optional_int32', 1, int) 630a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TestGetAndDeserialize('optional_int32', 1 << 30, int) 631a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TestGetAndDeserialize('optional_uint32', 1 << 30, int) 632b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer try: 633b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer integer_64 = long 634b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer except NameError: # Python3 635b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer integer_64 = int 636a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if struct.calcsize('L') == 4: 637a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Python only has signed ints, so 32-bit python can't fit an uint32 638a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # in an int. 639a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TestGetAndDeserialize('optional_uint32', 1 << 31, long) 640a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson else: 641a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # 64-bit python can fit uint32 inside an int 642a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson TestGetAndDeserialize('optional_uint32', 1 << 31, int) 643b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer TestGetAndDeserialize('optional_int64', 1 << 30, integer_64) 644b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer TestGetAndDeserialize('optional_int64', 1 << 60, integer_64) 645b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer TestGetAndDeserialize('optional_uint64', 1 << 30, integer_64) 646b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer TestGetAndDeserialize('optional_uint64', 1 << 60, integer_64) 647a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingleScalarBoundsChecking(self): 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def TestMinAndMaxIntegers(field_name, expected_min, expected_max): 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville pb = unittest_pb2.TestAllTypes() 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville setattr(pb, field_name, expected_min) 652a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(expected_min, getattr(pb, field_name)) 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville setattr(pb, field_name, expected_max) 654a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(expected_max, getattr(pb, field_name)) 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, setattr, pb, field_name, expected_min - 1) 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, setattr, pb, field_name, expected_max + 1) 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestMinAndMaxIntegers('optional_int32', -(1 << 31), (1 << 31) - 1) 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestMinAndMaxIntegers('optional_uint32', 0, 0xffffffff) 660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestMinAndMaxIntegers('optional_int64', -(1 << 63), (1 << 63) - 1) 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestMinAndMaxIntegers('optional_uint64', 0, 0xffffffffffffffff) 662a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 663a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson pb = unittest_pb2.TestAllTypes() 664a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson pb.optional_nested_enum = 1 665a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(1, pb.optional_nested_enum) 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalarTypeSafety(self): 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_int32.append, 1.1) 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_int32.append, 'foo') 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_string, 10) 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_bytes, 10) 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(10) 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32[0] = 23 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(IndexError, proto.repeated_int32.__setitem__, 500, 23) 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_int32.__setitem__, 0, 'abc') 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 679a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Repeated enums tests. 680a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson #proto.repeated_nested_enum.append(0) 681a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingleScalarGettersAndSetters(self): 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_int32) 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 1 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_int32) 687a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 688a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.optional_uint64 = 0xffffffffffff 689a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0xffffffffffff, proto.optional_uint64) 690a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.optional_uint64 = 0xffffffffffffffff 691a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0xffffffffffffffff, proto.optional_uint64) 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # TODO(robinson): Test all other scalar field types. 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSingleScalarClearField(self): 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Should be allowed to clear something that's not there (a no-op). 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('optional_int32') 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 1 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_int32')) 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('optional_int32') 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.optional_int32) 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('optional_int32')) 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # TODO(robinson): Test all other scalar field types. 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testEnums(self): 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.FOO) 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, unittest_pb2.TestAllTypes.FOO) 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto.BAR) 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, unittest_pb2.TestAllTypes.BAR) 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, proto.BAZ) 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, unittest_pb2.TestAllTypes.BAZ) 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 714a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testEnum_Name(self): 715a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('FOREIGN_FOO', 716a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Name(unittest_pb2.FOREIGN_FOO)) 717a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('FOREIGN_BAR', 718a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Name(unittest_pb2.FOREIGN_BAR)) 719a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('FOREIGN_BAZ', 720a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Name(unittest_pb2.FOREIGN_BAZ)) 721a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 722a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Name, 11312) 723a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 724a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 725a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('FOO', 726a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Name(proto.FOO)) 727a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('FOO', 728a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Name(proto.FOO)) 729a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('BAR', 730a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Name(proto.BAR)) 731a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('BAR', 732a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Name(proto.BAR)) 733a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('BAZ', 734a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Name(proto.BAZ)) 735a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('BAZ', 736a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Name(proto.BAZ)) 737a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 738a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Name, 11312) 739a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 740a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Name, 11312) 741a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 742a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testEnum_Value(self): 743a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(unittest_pb2.FOREIGN_FOO, 744a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Value('FOREIGN_FOO')) 745a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(unittest_pb2.FOREIGN_BAR, 746a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Value('FOREIGN_BAR')) 747a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(unittest_pb2.FOREIGN_BAZ, 748a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Value('FOREIGN_BAZ')) 749a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 750a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.ForeignEnum.Value, 'FO') 751a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 752a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 753a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.FOO, 754a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Value('FOO')) 755a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.FOO, 756a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Value('FOO')) 757a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.BAR, 758a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Value('BAR')) 759a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.BAR, 760a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Value('BAR')) 761a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.BAZ, 762a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Value('BAZ')) 763a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(proto.BAZ, 764a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Value('BAZ')) 765a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 766a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.NestedEnum.Value, 'Foo') 767a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, 768a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllTypes.NestedEnum.Value, 'Foo') 769a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 770a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testEnum_KeysAndValues(self): 771a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(['FOREIGN_FOO', 'FOREIGN_BAR', 'FOREIGN_BAZ'], 772b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer list(unittest_pb2.ForeignEnum.keys())) 773a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([4, 5, 6], 774b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer list(unittest_pb2.ForeignEnum.values())) 775a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([('FOREIGN_FOO', 4), ('FOREIGN_BAR', 5), 776a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ('FOREIGN_BAZ', 6)], 777b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer list(unittest_pb2.ForeignEnum.items())) 778a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 779a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 780b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(['FOO', 'BAR', 'BAZ', 'NEG'], list(proto.NestedEnum.keys())) 781b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual([1, 2, 3, -1], list(proto.NestedEnum.values())) 782a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([('FOO', 1), ('BAR', 2), ('BAZ', 3), ('NEG', -1)], 783b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer list(proto.NestedEnum.items())) 784a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalars(self): 786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.repeated_int32) 789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(proto.repeated_int32)) 790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(5) 791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(10) 792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(15) 793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.repeated_int32) 794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, len(proto.repeated_int32)) 795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 10, 15], proto.repeated_int32) 797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test single retrieval. 799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, proto.repeated_int32[0]) 800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(15, proto.repeated_int32[-1]) 801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test out-of-bounds indices. 802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(IndexError, proto.repeated_int32.__getitem__, 1234) 803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(IndexError, proto.repeated_int32.__getitem__, -1234) 804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test incorrect types passed to __getitem__. 805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_int32.__getitem__, 'foo') 806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_int32.__getitem__, None) 807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test single assignment. 809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32[1] = 20 810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 20, 15], proto.repeated_int32) 811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test insertion. 813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.insert(1, 25) 814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 25, 20, 15], proto.repeated_int32) 815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 816fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice retrieval. 817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(30) 818fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([25, 20, 15], proto.repeated_int32[1:4]) 819fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 25, 20, 15, 30], proto.repeated_int32[:]) 820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice assignment with an iterator 822b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.repeated_int32[1:4] = (i for i in range(3)) 823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 0, 1, 2, 30], proto.repeated_int32) 824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice assignment. 826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32[1:4] = [35, 40, 45] 827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 35, 40, 45, 30], proto.repeated_int32) 828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test that we can use the field as an iterator. 830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result = [] 831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for i in proto.repeated_int32: 832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result.append(i) 833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 35, 40, 45, 30], result) 834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test single deletion. 836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del proto.repeated_int32[2] 837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 35, 45, 30], proto.repeated_int32) 838fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice deletion. 840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del proto.repeated_int32[2:] 841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([5, 35], proto.repeated_int32) 842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 843a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Test extending. 844a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_int32.extend([3, 13]) 845a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([5, 35, 3, 13], proto.repeated_int32) 846a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test clearing. 848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('repeated_int32') 849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.repeated_int32) 850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(proto.repeated_int32)) 851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 852a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_int32.append(1) 853a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(1, proto.repeated_int32[-1]) 854a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Test assignment to a negative index. 855a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_int32[-1] = 2 856a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(2, proto.repeated_int32[-1]) 857a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 858a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Test deletion at negative indices. 859a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_int32[:] = [0, 1, 2, 3] 860a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto.repeated_int32[-1] 861a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([0, 1, 2], proto.repeated_int32) 862a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 863a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto.repeated_int32[-2] 864a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([0, 2], proto.repeated_int32) 865a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 866a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(IndexError, proto.repeated_int32.__delitem__, -3) 867a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(IndexError, proto.repeated_int32.__delitem__, 300) 868a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 869a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto.repeated_int32[-2:-1] 870a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([2], proto.repeated_int32) 871a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 872a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson del proto.repeated_int32[100:10000] 873a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([2], proto.repeated_int32) 874a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 875fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalarsRemove(self): 876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 877fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.repeated_int32) 879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(proto.repeated_int32)) 880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(5) 881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(10) 882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(5) 883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.append(5) 884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, len(proto.repeated_int32)) 886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.remove(5) 887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, len(proto.repeated_int32)) 888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(10, proto.repeated_int32[0]) 889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, proto.repeated_int32[1]) 890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, proto.repeated_int32[2]) 891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.remove(5) 893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, len(proto.repeated_int32)) 894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(10, proto.repeated_int32[0]) 895fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, proto.repeated_int32[1]) 896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 897fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.repeated_int32.remove(10) 898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, len(proto.repeated_int32)) 899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, proto.repeated_int32[0]) 900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Remove a non-existent element. 902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, proto.repeated_int32.remove, 123) 903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedComposites(self): 905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.repeated_nested_message) 907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(proto.repeated_nested_message)) 908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m0 = proto.repeated_nested_message.add() 909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m1 = proto.repeated_nested_message.add() 910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.repeated_nested_message) 911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, len(proto.repeated_nested_message)) 912a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual([m0, m1], proto.repeated_nested_message) 913b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertIsInstance(m0, unittest_pb2.TestAllTypes.NestedMessage) 914fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test out-of-bounds indices. 916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(IndexError, proto.repeated_nested_message.__getitem__, 917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1234) 918fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(IndexError, proto.repeated_nested_message.__getitem__, 919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville -1234) 920fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test incorrect types passed to __getitem__. 922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_nested_message.__getitem__, 923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 'foo') 924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, proto.repeated_nested_message.__getitem__, 925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville None) 926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice retrieval. 928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m2 = proto.repeated_nested_message.add() 929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m3 = proto.repeated_nested_message.add() 930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m4 = proto.repeated_nested_message.add() 931a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual( 932a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson [m1, m2, m3], proto.repeated_nested_message[1:4]) 933a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual( 934a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson [m0, m1, m2, m3, m4], proto.repeated_nested_message[:]) 935a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual( 936a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson [m0, m1], proto.repeated_nested_message[:2]) 937a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual( 938a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson [m2, m3, m4], proto.repeated_nested_message[2:]) 939a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 940a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m0, proto.repeated_nested_message[0]) 941a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual( 942a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson [m0], proto.repeated_nested_message[:1]) 943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test that we can use the field as an iterator. 945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result = [] 946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for i in proto.repeated_nested_message: 947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville result.append(i) 948a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual([m0, m1, m2, m3, m4], result) 949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test single deletion. 951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del proto.repeated_nested_message[2] 952a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual([m0, m1, m3, m4], proto.repeated_nested_message) 953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test slice deletion. 955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del proto.repeated_nested_message[2:] 956a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual([m0, m1], proto.repeated_nested_message) 957a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 958a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Test extending. 959a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson n1 = unittest_pb2.TestAllTypes.NestedMessage(bb=1) 960a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson n2 = unittest_pb2.TestAllTypes.NestedMessage(bb=2) 961a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_nested_message.extend([n1,n2]) 962a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(4, len(proto.repeated_nested_message)) 963a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(n1, proto.repeated_nested_message[2]) 964a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(n2, proto.repeated_nested_message[3]) 965fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test clearing. 967fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.ClearField('repeated_nested_message') 968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.repeated_nested_message) 969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(proto.repeated_nested_message)) 970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 971a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Test constructing an element while adding it. 972a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_nested_message.add(bb=23) 973a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(1, len(proto.repeated_nested_message)) 974a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(23, proto.repeated_nested_message[0].bb) 975a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 976a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testRepeatedCompositeRemove(self): 977a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 978a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 979a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, len(proto.repeated_nested_message)) 980a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m0 = proto.repeated_nested_message.add() 981a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Need to set some differentiating variable so m0 != m1 != m2: 982a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m0.bb = len(proto.repeated_nested_message) 983a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m1 = proto.repeated_nested_message.add() 984a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m1.bb = len(proto.repeated_nested_message) 985a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(m0 != m1) 986a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m2 = proto.repeated_nested_message.add() 987a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m2.bb = len(proto.repeated_nested_message) 988a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertListsEqual([m0, m1, m2], proto.repeated_nested_message) 989a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 990a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(3, len(proto.repeated_nested_message)) 991a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_nested_message.remove(m0) 992a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(2, len(proto.repeated_nested_message)) 993a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(m1, proto.repeated_nested_message[0]) 994a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(m2, proto.repeated_nested_message[1]) 995a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 996a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Removing m0 again or removing None should raise error 997a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, proto.repeated_nested_message.remove, m0) 998a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(ValueError, proto.repeated_nested_message.remove, None) 999a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(2, len(proto.repeated_nested_message)) 1000a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1001a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.repeated_nested_message.remove(m2) 1002a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(1, len(proto.repeated_nested_message)) 1003a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(m1, proto.repeated_nested_message[0]) 1004a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHandWrittenReflection(self): 1006a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Hand written extensions are only supported by the pure-Python 1007a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # implementation of the API. 1008a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() != 'python': 1009a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return 1010a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FieldDescriptor = descriptor.FieldDescriptor 1012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foo_field_descriptor = FieldDescriptor( 1013fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville name='foo_field', full_name='MyProto.foo_field', 1014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville index=0, number=1, type=FieldDescriptor.TYPE_INT64, 1015fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville cpp_type=FieldDescriptor.CPPTYPE_INT64, 1016fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville label=FieldDescriptor.LABEL_OPTIONAL, default_value=0, 1017fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville containing_type=None, message_type=None, enum_type=None, 1018fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville is_extension=False, extension_scope=None, 1019fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville options=descriptor_pb2.FieldOptions()) 1020fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville mydescriptor = descriptor.Descriptor( 1021fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville name='MyProto', full_name='MyProto', filename='ignored', 1022fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville containing_type=None, nested_types=[], enum_types=[], 1023fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville fields=[foo_field_descriptor], extensions=[], 1024fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville options=descriptor_pb2.MessageOptions()) 1025b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer class MyProtoClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): 1026fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DESCRIPTOR = mydescriptor 1027fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville myproto_instance = MyProtoClass() 1028fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, myproto_instance.foo_field) 1029fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not myproto_instance.HasField('foo_field')) 1030fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville myproto_instance.foo_field = 23 1031fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, myproto_instance.foo_field) 1032fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(myproto_instance.HasField('foo_field')) 1033fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1034a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDescriptorProtoSupport(self): 1035a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Hand written descriptors/reflection are only supported by the pure-Python 1036a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # implementation of the API. 1037a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() != 'python': 1038a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return 1039a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1040a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def AddDescriptorField(proto, field_name, field_type): 1041a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField.field_index += 1 1042a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field = proto.field.add() 1043a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.name = field_name 1044a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.type = field_type 1045a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.number = AddDescriptorField.field_index 1046a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.label = descriptor_pb2.FieldDescriptorProto.LABEL_OPTIONAL 1047a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1048a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField.field_index = 0 1049a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1050a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson desc_proto = descriptor_pb2.DescriptorProto() 1051a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson desc_proto.name = 'Car' 1052a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson fdp = descriptor_pb2.FieldDescriptorProto 1053a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField(desc_proto, 'name', fdp.TYPE_STRING) 1054a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField(desc_proto, 'year', fdp.TYPE_INT64) 1055a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField(desc_proto, 'automatic', fdp.TYPE_BOOL) 1056a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField(desc_proto, 'price', fdp.TYPE_DOUBLE) 1057a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Add a repeated field 1058a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson AddDescriptorField.field_index += 1 1059a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field = desc_proto.field.add() 1060a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.name = 'owners' 1061a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.type = fdp.TYPE_STRING 1062a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.number = AddDescriptorField.field_index 1063a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_field.label = descriptor_pb2.FieldDescriptorProto.LABEL_REPEATED 1064a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1065a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson desc = descriptor.MakeDescriptor(desc_proto) 1066b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue('name' in desc.fields_by_name) 1067b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue('year' in desc.fields_by_name) 1068b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue('automatic' in desc.fields_by_name) 1069b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue('price' in desc.fields_by_name) 1070b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue('owners' in desc.fields_by_name) 1071b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 1072b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer class CarMessage(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): 1073a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson DESCRIPTOR = desc 1074a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1075a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius = CarMessage() 1076a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius.name = 'prius' 1077a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius.year = 2010 1078a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius.automatic = True 1079a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius.price = 25134.75 1080a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson prius.owners.extend(['bob', 'susan']) 1081a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1082a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized_prius = prius.SerializeToString() 1083a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson new_prius = reflection.ParseMessage(desc, serialized_prius) 1084a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(new_prius is not prius) 1085a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius, new_prius) 1086a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1087a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # these are unnecessary assuming message equality works as advertised but 1088a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # explicitly check to be safe since we're mucking about in metaclass foo 1089a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius.name, new_prius.name) 1090a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius.year, new_prius.year) 1091a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius.automatic, new_prius.automatic) 1092a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius.price, new_prius.price) 1093a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(prius.owners, new_prius.owners) 1094a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testTopLevelExtensionsForOptionalScalar(self): 1096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.optional_int32_extension 1098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, extendee_proto.Extensions[extension]) 1100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # As with normal scalar fields, just doing a read doesn't actually set the 1101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # "has" bit. 1102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Actually set the thing. 1104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.Extensions[extension] = 23 1105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, extendee_proto.Extensions[extension]) 1106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(extendee_proto.HasExtension(extension)) 1107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that clearing works as well. 1108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, extendee_proto.Extensions[extension]) 1110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testTopLevelExtensionsForRepeatedScalar(self): 1113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.repeated_string_extension 1115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(extendee_proto.Extensions[extension])) 1116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.Extensions[extension].append('foo') 1117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(['foo'], extendee_proto.Extensions[extension]) 1118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string_list = extendee_proto.Extensions[extension] 1119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(extendee_proto.Extensions[extension])) 1121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(string_list is not extendee_proto.Extensions[extension]) 1122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't be allowed to do Extensions[extension] = 'a' 1123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, operator.setitem, extendee_proto.Extensions, 1124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension, 'a') 1125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testTopLevelExtensionsForOptionalMessage(self): 1127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.optional_foreign_message_extension 1129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, extendee_proto.Extensions[extension].c) 1131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # As with normal (non-extension) fields, merely reading from the 1132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # thing shouldn't set the "has" bit. 1133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.Extensions[extension].c = 23 1135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, extendee_proto.Extensions[extension].c) 1136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(extendee_proto.HasExtension(extension)) 1137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Save a reference here. 1138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message = extendee_proto.Extensions[extension] 1139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(foreign_message is not extendee_proto.Extensions[extension]) 1141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Setting a field on foreign_message now shouldn't set 1142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # any "has" bits on extendee_proto. 1143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message.c = 42 1144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(42, foreign_message.c) 1145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(foreign_message.HasField('c')) 1146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't be allowed to do Extensions[extension] = 'a' 1148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, operator.setitem, extendee_proto.Extensions, 1149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension, 'a') 1150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testTopLevelExtensionsForRepeatedMessage(self): 1152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.repeatedgroup_extension 1154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(extendee_proto.Extensions[extension])) 1155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group = extendee_proto.Extensions[extension].add() 1156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group.a = 23 1157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, extendee_proto.Extensions[extension][0].a) 1158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group.a = 42 1159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(42, extendee_proto.Extensions[extension][0].a) 1160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group_list = extendee_proto.Extensions[extension] 1161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(extendee_proto.Extensions[extension])) 1163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(group_list is not extendee_proto.Extensions[extension]) 1164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't be allowed to do Extensions[extension] = 'a' 1165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, operator.setitem, extendee_proto.Extensions, 1166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension, 'a') 1167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNestedExtensions(self): 1169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.TestRequired.single 1171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # We just test the non-repeated case. 1173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville required = extendee_proto.Extensions[extension] 1175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, required.a) 1176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville required.a = 23 1178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, extendee_proto.Extensions[extension].a) 1179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(extendee_proto.HasExtension(extension)) 1180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(required is not extendee_proto.Extensions[extension]) 1182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not extendee_proto.HasExtension(extension)) 1183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1184a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testRegisteredExtensions(self): 1185a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue('protobuf_unittest.optional_int32_extension' in 1186a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unittest_pb2.TestAllExtensions._extensions_by_name) 1187a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(1 in unittest_pb2.TestAllExtensions._extensions_by_number) 1188a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Make sure extensions haven't been registered into types that shouldn't 1189a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # have any. 1190b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(0, len(unittest_pb2.TestAllTypes._extensions_by_name)) 1191a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # If message A directly contains message B, and 1193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # a.HasField('b') is currently False, then mutating any 1194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # extension in B should change a.HasField('b') to True 1195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # (and so on up the object tree). 1196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testHasBitsForAncestorsOfExtendedMessage(self): 1197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Optional scalar extension. 1198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel = more_extensions_pb2.TopLevelMessage() 1199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, toplevel.submessage.Extensions[ 1201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_int_extension]) 1202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel.submessage.Extensions[ 1204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_int_extension] = 23 1205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, toplevel.submessage.Extensions[ 1206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_int_extension]) 1207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(toplevel.HasField('submessage')) 1208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Repeated scalar extension. 1210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel = more_extensions_pb2.TopLevelMessage() 1211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([], toplevel.submessage.Extensions[ 1213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_int_extension]) 1214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel.submessage.Extensions[ 1216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_int_extension].append(23) 1217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([23], toplevel.submessage.Extensions[ 1218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_int_extension]) 1219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(toplevel.HasField('submessage')) 1220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Optional message extension. 1222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel = more_extensions_pb2.TopLevelMessage() 1223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, toplevel.submessage.Extensions[ 1225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_message_extension].foreign_message_int) 1226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel.submessage.Extensions[ 1228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_message_extension].foreign_message_int = 23 1229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, toplevel.submessage.Extensions[ 1230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.optional_message_extension].foreign_message_int) 1231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(toplevel.HasField('submessage')) 1232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Repeated message extension. 1234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel = more_extensions_pb2.TopLevelMessage() 1235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, len(toplevel.submessage.Extensions[ 1237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_message_extension])) 1238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not toplevel.HasField('submessage')) 1239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign = toplevel.submessage.Extensions[ 1240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_message_extension].add() 1241a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(foreign, toplevel.submessage.Extensions[ 1242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville more_extensions_pb2.repeated_message_extension][0]) 1243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(toplevel.HasField('submessage')) 1244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testDisconnectionAfterClearingEmptyMessage(self): 1246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville toplevel = more_extensions_pb2.TopLevelMessage() 1247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = toplevel.submessage 1248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = more_extensions_pb2.optional_message_extension 1249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension_proto = extendee_proto.Extensions[extension] 1250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto.ClearExtension(extension) 1251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension_proto.foreign_message_int = 23 1252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(extension_proto is not extendee_proto.Extensions[extension]) 1254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testExtensionFailureModes(self): 1256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extendee_proto = unittest_pb2.TestAllExtensions() 1257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Try non-extension-handle arguments to HasExtension, 1259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # ClearExtension(), and Extensions[]... 1260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(KeyError, extendee_proto.HasExtension, 1234) 1261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(KeyError, extendee_proto.ClearExtension, 1234) 1262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(KeyError, extendee_proto.Extensions.__getitem__, 1234) 1263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(KeyError, extendee_proto.Extensions.__setitem__, 1234, 5) 1264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Try something that *is* an extension handle, just not for 1266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # this message... 1267b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer for unknown_handle in (more_extensions_pb2.optional_int_extension, 1268b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer more_extensions_pb2.optional_message_extension, 1269b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer more_extensions_pb2.repeated_int_extension, 1270b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer more_extensions_pb2.repeated_message_extension): 1271b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertRaises(KeyError, extendee_proto.HasExtension, 1272b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unknown_handle) 1273b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertRaises(KeyError, extendee_proto.ClearExtension, 1274b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unknown_handle) 1275b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertRaises(KeyError, extendee_proto.Extensions.__getitem__, 1276b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unknown_handle) 1277b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertRaises(KeyError, extendee_proto.Extensions.__setitem__, 1278b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unknown_handle, 5) 1279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Try call HasExtension() with a valid handle, but for a 1281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # *repeated* field. (Just as with non-extension repeated 1282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # fields, Has*() isn't supported for extension repeated fields). 1283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(KeyError, extendee_proto.HasExtension, 1284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.repeated_string_extension) 1285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testStaticParseFrom(self): 1287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(proto1) 1289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string1 = proto1.SerializeToString() 1291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes.FromString(string1) 1292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Messages should be equal. 1294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto2, proto1) 1295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromSingularField(self): 1297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test merge with just a singular field. 1298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optional_int32 = 1 1300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # This shouldn't get overwritten. 1303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.optional_string = 'value' 1304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.optional_int32) 1307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('value', proto2.optional_string) 1308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromRepeatedField(self): 1310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test merge with just a repeated field. 1311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.repeated_int32.append(1) 1313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.repeated_int32.append(2) 1314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.repeated_int32.append(0) 1317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto2.repeated_int32[0]) 1320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.repeated_int32[1]) 1321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto2.repeated_int32[2]) 1322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromOptionalGroup(self): 1324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test merge with an optional group. 1325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optionalgroup.a = 12 1327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(12, proto2.optionalgroup.a) 1330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromRepeatedNestedMessage(self): 1332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test merge with a repeated nested message. 1333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = proto1.repeated_nested_message.add() 1335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 123 1336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = proto1.repeated_nested_message.add() 1337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 321 1338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = proto2.repeated_nested_message.add() 1341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 999 1342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(999, proto2.repeated_nested_message[0].bb) 1344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(123, proto2.repeated_nested_message[1].bb) 1345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(321, proto2.repeated_nested_message[2].bb) 1346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1347a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto3 = unittest_pb2.TestAllTypes() 1348a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto3.repeated_nested_message.MergeFrom(proto2.repeated_nested_message) 1349a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(999, proto3.repeated_nested_message[0].bb) 1350a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(123, proto3.repeated_nested_message[1].bb) 1351a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(321, proto3.repeated_nested_message[2].bb) 1352a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromAllFields(self): 1354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # With all fields set. 1355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(proto1) 1357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Messages should be equal. 1361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto2, proto1) 1362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Serialized string should be equal too. 1364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string1 = proto1.SerializeToString() 1365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string2 = proto2.SerializeToString() 1366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(string1, string2) 1367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromExtensionsSingular(self): 1369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllExtensions() 1370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.Extensions[unittest_pb2.optional_int32_extension] = 1 1371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllExtensions() 1373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1, proto2.Extensions[unittest_pb2.optional_int32_extension]) 1376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromExtensionsRepeated(self): 1378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllExtensions() 1379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.Extensions[unittest_pb2.repeated_int32_extension].append(1) 1380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.Extensions[unittest_pb2.repeated_int32_extension].append(2) 1381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllExtensions() 1383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.Extensions[unittest_pb2.repeated_int32_extension].append(0) 1384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 3, len(proto2.Extensions[unittest_pb2.repeated_int32_extension])) 1387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 0, proto2.Extensions[unittest_pb2.repeated_int32_extension][0]) 1389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1, proto2.Extensions[unittest_pb2.repeated_int32_extension][1]) 1391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2, proto2.Extensions[unittest_pb2.repeated_int32_extension][2]) 1393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromExtensionsNestedMessage(self): 1395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllExtensions() 1396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ext1 = proto1.Extensions[ 1397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.repeated_nested_message_extension] 1398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = ext1.add() 1399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 222 1400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = ext1.add() 1401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 333 1402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllExtensions() 1404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ext2 = proto2.Extensions[ 1405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.repeated_nested_message_extension] 1406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m = ext2.add() 1407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville m.bb = 111 1408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.MergeFrom(proto1) 1410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ext2 = proto2.Extensions[ 1411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.repeated_nested_message_extension] 1412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, len(ext2)) 1413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(111, ext2[0].bb) 1414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(222, ext2[1].bb) 1415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(333, ext2[2].bb) 1416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1417a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testMergeFromBug(self): 1418a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message1 = unittest_pb2.TestAllTypes() 1419a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message2 = unittest_pb2.TestAllTypes() 1420a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1421a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Cause optional_nested_message to be instantiated within message1, even 1422a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # though it is not considered to be "present". 1423a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message1.optional_nested_message 1424a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(message1.HasField('optional_nested_message')) 1425a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1426a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Merge into message2. This should not instantiate the field is message2. 1427a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message2.MergeFrom(message1) 1428a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(message2.HasField('optional_nested_message')) 1429a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCopyFromSingularField(self): 1431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test copy with just a singular field. 1432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optional_int32 = 1 1434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optional_string = 'important-text' 1435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.optional_string = 'value' 1438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.CopyFrom(proto1) 1440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.optional_int32) 1441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('important-text', proto2.optional_string) 1442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCopyFromRepeatedField(self): 1444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test copy with a repeated field. 1445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.repeated_int32.append(1) 1447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.repeated_int32.append(2) 1448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.repeated_int32.append(0) 1451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.CopyFrom(proto1) 1452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.repeated_int32[0]) 1454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto2.repeated_int32[1]) 1455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCopyFromAllFields(self): 1457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # With all fields set. 1458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(proto1) 1460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestAllTypes() 1461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2.CopyFrom(proto1) 1462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Messages should be equal. 1464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto2, proto1) 1465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Serialized string should be equal too. 1467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string1 = proto1.SerializeToString() 1468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville string2 = proto2.SerializeToString() 1469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(string1, string2) 1470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCopyFromSelf(self): 1472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1 = unittest_pb2.TestAllTypes() 1473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.repeated_int32.append(1) 1474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optional_int32 = 2 1475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.optional_string = 'important-text' 1476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto1.CopyFrom(proto1) 1478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto1.repeated_int32[0]) 1479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto1.optional_int32) 1480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('important-text', proto1.optional_string) 1481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1482a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testCopyFromBadType(self): 1483a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # The python implementation doesn't raise an exception in this 1484a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # case. In theory it should. 1485a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() == 'python': 1486a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return 1487a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1 = unittest_pb2.TestAllTypes() 1488a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = unittest_pb2.TestAllExtensions() 1489a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(TypeError, proto1.CopyFrom, proto2) 1490a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1491a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDeepCopy(self): 1492a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1 = unittest_pb2.TestAllTypes() 1493a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1.optional_int32 = 1 1494a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = copy.deepcopy(proto1) 1495a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(1, proto2.optional_int32) 1496a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1497a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1.repeated_int32.append(2) 1498a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto1.repeated_int32.append(3) 1499a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson container = copy.deepcopy(proto1.repeated_int32) 1500a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual([2, 3], container) 1501a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1502a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # TODO(anuraag): Implement deepcopy for repeated composite / extension dict 1503a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testClear(self): 1505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 1506a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # C++ implementation does not support lazy fields right now so leave it 1507a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # out for now. 1508a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() == 'python': 1509a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson test_util.SetAllFields(proto) 1510a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson else: 1511a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson test_util.SetAllNonLazyFields(proto) 1512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Clear the message. 1513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Clear() 1514b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(proto.ByteSize(), 0) 1515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville empty_proto = unittest_pb2.TestAllTypes() 1516b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(proto, empty_proto) 1517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test if extensions which were set are cleared. 1519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 1520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllExtensions(proto) 1521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Clear the message. 1522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Clear() 1523b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(proto.ByteSize(), 0) 1524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville empty_proto = unittest_pb2.TestAllExtensions() 1525b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(proto, empty_proto) 1526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1527a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testDisconnectingBeforeClear(self): 1528a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 1529a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.optional_nested_message 1530a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.Clear() 1531a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(nested is not proto.optional_nested_message) 1532a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested.bb = 23 1533a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(not proto.HasField('optional_nested_message')) 1534a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.optional_nested_message.bb) 1535a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1536a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 1537a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.optional_nested_message 1538a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested.bb = 5 1539a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson foreign = proto.optional_foreign_message 1540a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson foreign.c = 6 1541a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1542a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.Clear() 1543a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(nested is not proto.optional_nested_message) 1544a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(foreign is not proto.optional_foreign_message) 1545a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(5, nested.bb) 1546a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(6, foreign.c) 1547a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested.bb = 15 1548a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson foreign.c = 16 1549a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto.HasField('optional_nested_message')) 1550a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.optional_nested_message.bb) 1551a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto.HasField('optional_foreign_message')) 1552a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.optional_foreign_message.c) 1553a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1554a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testOneOf(self): 1555a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 1556a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.oneof_uint32 = 10 1557a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.oneof_nested_message.bb = 11 1558a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(11, proto.oneof_nested_message.bb) 1559a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto.HasField('oneof_uint32')) 1560a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested = proto.oneof_nested_message 1561a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.oneof_string = 'abc' 1562a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual('abc', proto.oneof_string) 1563a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(11, nested.bb) 1564a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto.HasField('oneof_nested_message')) 1565a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1566d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def assertInitialized(self, proto): 1567d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.IsInitialized()) 1568d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Neither method should raise an exception. 1569d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString() 1570d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializePartialToString() 1571d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1572d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def assertNotInitialized(self, proto): 1573d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertFalse(proto.IsInitialized()) 1574d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertRaises(message.EncodeError, proto.SerializeToString) 1575d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # "Partial" serialization doesn't care if message is uninitialized. 1576d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializePartialToString() 1577d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testIsInitialized(self): 1579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Trivial cases - all optional fields and extensions. 1580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 1581d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 1583d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # The case of uninitialized required fields. 1586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestRequired() 1587d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.a = proto.b = proto.c = 2 1589d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # The case of uninitialized submessage. 1592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestRequiredForeign() 1593d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_message.a = 1 1595d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_message.b = 0 1597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_message.c = 0 1598d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Uninitialized repeated submessage. 1601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1 = proto.repeated_message.add() 1602d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.a = message1.b = message1.c = 0 1604d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Uninitialized repeated group in an extension. 1607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 1608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.TestRequired.multi 1609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1 = proto.Extensions[extension].add() 1610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message2 = proto.Extensions[extension].add() 1611d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.a = 1 1613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.b = 1 1614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.c = 1 1615d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message2.a = 2 1617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message2.b = 2 1618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message2.c = 2 1619d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Uninitialized nonrepeated message in an extension. 1622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 1623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.TestRequired.single 1624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension].a = 1 1625d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertNotInitialized(proto) 1626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension].b = 2 1627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension].c = 3 1628d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertInitialized(proto) 1629d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1630d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Try passing an errors list. 1631d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville errors = [] 1632d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestRequired() 1633d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertFalse(proto.IsInitialized(errors)) 1634d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(errors, ['a', 'b', 'c']) 1635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1636b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer @unittest.skipIf( 1637a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson api_implementation.Type() != 'cpp' or api_implementation.Version() != 2, 1638a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Errors are only available from the most recent C++ implementation.') 1639a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testFileDescriptorErrors(self): 1640a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_name = 'test_file_descriptor_errors.proto' 1641a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson package_name = 'test_file_descriptor_errors.proto' 1642a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor_proto = descriptor_pb2.FileDescriptorProto() 1643a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor_proto.name = file_name 1644a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor_proto.package = package_name 1645a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m1 = file_descriptor_proto.message_type.add() 1646a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m1.name = 'msg1' 1647a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Compiles the proto into the C++ descriptor pool 1648a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson descriptor.FileDescriptor( 1649a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_name, 1650a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson package_name, 1651a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized_pb=file_descriptor_proto.SerializeToString()) 1652a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Add a FileDescriptorProto that has duplicate symbols 1653a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson another_file_name = 'another_test_file_descriptor_errors.proto' 1654a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor_proto.name = another_file_name 1655a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m2 = file_descriptor_proto.message_type.add() 1656a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson m2.name = 'msg2' 1657a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson with self.assertRaises(TypeError) as cm: 1658a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson descriptor.FileDescriptor( 1659a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson another_file_name, 1660a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson package_name, 1661a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized_pb=file_descriptor_proto.SerializeToString()) 1662a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(hasattr(cm, 'exception'), '%s not raised' % 1663a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson getattr(cm.expected, '__name__', cm.expected)) 1664a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertIn('test_file_descriptor_errors.proto', str(cm.exception)) 1665a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Error message will say something about this definition being a 1666a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # duplicate, though we don't check the message exactly to avoid a 1667a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # dependency on the C++ logging code. 1668a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertIn('test_file_descriptor_errors.msg1', str(cm.exception)) 1669a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testStringUTF8Encoding(self): 1671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 1672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assignment of a unicode object to a field of type 'bytes' is not allowed. 1674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(TypeError, 1675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville setattr, proto, 'optional_bytes', u'unicode object') 1676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check that the default value is of python's 'unicode' type. 1678b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(type(proto.optional_string), six.text_type) 1679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1680b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.optional_string = six.text_type('Testing') 1681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto.optional_string, str('Testing')) 1682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Assign a value of type 'str' which can be encoded in UTF-8. 1684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_string = str('Testing') 1685b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(proto.optional_string, six.text_type('Testing')) 1686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1687b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # Try to assign a 'bytes' object which contains non-UTF-8. 1688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertRaises(ValueError, 1689a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson setattr, proto, 'optional_string', b'a\x80a') 1690b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # No exception: Assign already encoded UTF-8 bytes to a string field. 1691b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer utf8_bytes = u'Тест'.encode('utf-8') 1692b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.optional_string = utf8_bytes 1693b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # No exception: Assign the a non-ascii unicode object. 1694b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.optional_string = u'Тест' 1695b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # No exception thrown (normal str assignment containing ASCII). 1696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_string = 'abc' 1697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testStringUTF8Serialization(self): 1699b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto = message_set_extensions_pb2.TestMessageSet() 1700b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message = message_set_extensions_pb2.TestMessageSetExtension2 1701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = extension_message.message_set_extension 1702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_utf8 = u'Тест' 1704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_utf8_bytes = test_utf8.encode('utf-8') 1705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 'Test' in another language, using UTF-8 charset. 1707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension].str = test_utf8 1708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Serialize using the MessageSet wire format (this is specified in the 1710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # .proto file). 1711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 1712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check byte size. 1714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto.ByteSize(), len(serialized)) 1715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raw = unittest_mset_pb2.RawMessageSet() 1717a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bytes_read = raw.MergeFromString(serialized) 1718a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(len(serialized), bytes_read) 1719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1720b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message2 = message_set_extensions_pb2.TestMessageSetExtension2() 1721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, len(raw.item)) 1723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check that the type_id is the same as the tag ID in the .proto file. 1724b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(raw.item[0].type_id, 98418634) 1725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1726a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Check the actual bytes on the wire. 1727b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertTrue(raw.item[0].message.endswith(test_utf8_bytes)) 1728a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bytes_read = message2.MergeFromString(raw.item[0].message) 1729a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(len(raw.item[0].message), bytes_read) 1730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1731b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(type(message2.str), six.text_type) 1732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(message2.str, test_utf8) 1733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1734a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # The pure Python API throws an exception on MergeFromString(), 1735a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # if any of the string fields of the message can't be UTF-8 decoded. 1736a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # The C++ implementation of the API has no way to check that on 1737a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # MergeFromString and thus has no way to throw the exception. 1738a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # 1739a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # The pure Python API always returns objects of type 'unicode' (UTF-8 1740a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # encoded), or 'bytes' (in 7 bit ASCII). 1741a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson badbytes = raw.item[0].message.replace( 1742a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson test_utf8_bytes, len(test_utf8_bytes) * b'\xff') 1743a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1744a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unicode_decode_failed = False 1745a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson try: 1746a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message2.MergeFromString(badbytes) 1747a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson except UnicodeDecodeError: 1748a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unicode_decode_failed = True 1749a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson string_field = message2.str 1750a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertTrue(unicode_decode_failed or type(string_field) is bytes) 1751a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1752a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testBytesInTextFormat(self): 1753a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes(optional_bytes=b'\x00\x7f\x80\xff') 1754a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(u'optional_bytes: "\\000\\177\\200\\377"\n', 1755b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer six.text_type(proto)) 1756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1757d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testEmptyNestedMessage(self): 1758d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes() 1759d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_nested_message.MergeFrom( 1760d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage()) 1761d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.HasField('optional_nested_message')) 1762d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1763d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes() 1764d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_nested_message.CopyFrom( 1765d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unittest_pb2.TestAllTypes.NestedMessage()) 1766d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.HasField('optional_nested_message')) 1767d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1768d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes() 1769a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bytes_read = proto.optional_nested_message.MergeFromString(b'') 1770a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, bytes_read) 1771d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.HasField('optional_nested_message')) 1772d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1773d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes() 1774a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.optional_nested_message.ParseFromString(b'') 1775d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.HasField('optional_nested_message')) 1776d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1777d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville serialized = proto.SerializeToString() 1778d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto2 = unittest_pb2.TestAllTypes() 1779a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 1780a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 1781a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(serialized)) 1782d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto2.HasField('optional_nested_message')) 1783d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1784d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testSetInParent(self): 1785d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestAllTypes() 1786d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertFalse(proto.HasField('optionalgroup')) 1787d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optionalgroup.SetInParent() 1788d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertTrue(proto.HasField('optionalgroup')) 1789d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 1790b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer def testPackageInitializationImport(self): 1791b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer """Test that we can import nested messages from their __init__.py. 1792b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 1793b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer Such setup is not trivial since at the time of processing of __init__.py one 1794b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer can't refer to its submodules by name in code, so expressions like 1795b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer google.protobuf.internal.import_test_package.inner_pb2 1796b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer don't work. They do work in imports, so we have assign an alias at import 1797b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer and then use that alias in generated code. 1798b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer """ 1799b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # We import here since it's the import that used to fail, and we want 1800b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # the failure to have the right context. 1801b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # pylint: disable=g-import-not-at-top 1802b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer from google.protobuf.internal import import_test_package 1803b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # pylint: enable=g-import-not-at-top 1804b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer msg = import_test_package.myproto.Outer() 1805b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # Just check the default value. 1806b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(57, msg.inner.value) 1807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# Since we had so many tests for protocol buffer equality, we broke these out 1809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# into separate TestCase classes. 1810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1812b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass TestAllTypesEqualityTest(unittest.TestCase): 1813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def setUp(self): 1815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto = unittest_pb2.TestAllTypes() 1816fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto = unittest_pb2.TestAllTypes() 1817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1818a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testNotHashable(self): 1819a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(TypeError, hash, self.first_proto) 1820a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSelfEquality(self): 1822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.first_proto) 1823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testEmptyProtosEqual(self): 1825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1828b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass FullProtosEqualityTest(unittest.TestCase): 1829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville """Equality tests using completely-full protos as a starting point.""" 1831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def setUp(self): 1833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto = unittest_pb2.TestAllTypes() 1834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto = unittest_pb2.TestAllTypes() 1835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(self.first_proto) 1836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(self.second_proto) 1837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1838a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testNotHashable(self): 1839a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertRaises(TypeError, hash, self.first_proto) 1840a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNoneNotEqual(self): 1842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, None) 1843fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(None, self.second_proto) 1844fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1845fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNotEqualToOtherMessage(self): 1846fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville third_proto = unittest_pb2.TestRequired() 1847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, third_proto) 1848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(third_proto, self.second_proto) 1849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testAllFieldsFilledEquality(self): 1851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1852fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1853fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNonRepeatedScalar(self): 1854fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Nonrepeated scalar field change should cause inequality. 1855fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_int32 += 1 1856fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1857fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # ...as should clearing a field. 1858fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.ClearField('optional_int32') 1859fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1860fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1861fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNonRepeatedComposite(self): 1862fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Change a nonrepeated composite field. 1863fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.bb += 1 1864fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1865fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.bb -= 1 1866fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1867fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Clear a field in the nested message. 1868fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.ClearField('bb') 1869fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1870fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.bb = ( 1871fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto.optional_nested_message.bb) 1872fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1873fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Remove the nested message entirely. 1874fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.ClearField('optional_nested_message') 1875fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1877fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalar(self): 1878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Change a repeated scalar field. 1879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.repeated_int32.append(5) 1880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.ClearField('repeated_int32') 1882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedComposite(self): 1885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Change value within a repeated composite field. 1886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.repeated_nested_message[0].bb += 1 1887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.repeated_nested_message[0].bb -= 1 1889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Add a value to a repeated composite field. 1891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.repeated_nested_message.add() 1892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto.repeated_nested_message.add() 1894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1895fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNonRepeatedScalarHasBits(self): 1897fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we test "has" bits as well as value for 1898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # nonrepeated scalar field. 1899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.ClearField('optional_int32') 1900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto.optional_int32 = 0 1901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testNonRepeatedCompositeHasBits(self): 1904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we test "has" bits as well as value for 1905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # nonrepeated composite field. 1906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.ClearField('optional_nested_message') 1907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.second_proto.optional_nested_message.ClearField('bb') 1908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(self.first_proto, self.second_proto) 1909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.bb = 0 1910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.first_proto.optional_nested_message.ClearField('bb') 1911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(self.first_proto, self.second_proto) 1912fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1913fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1914b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass ExtensionEqualityTest(unittest.TestCase): 1915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testExtensionEquality(self): 1917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllExtensions() 1918fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllExtensions() 1919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1920fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllExtensions(first_proto) 1921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(first_proto, second_proto) 1922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllExtensions(second_proto) 1923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we check value equality. 1926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.Extensions[unittest_pb2.optional_int32_extension] += 1 1927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(first_proto, second_proto) 1928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.Extensions[unittest_pb2.optional_int32_extension] -= 1 1929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we also look at "has" bits. 1932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.ClearExtension(unittest_pb2.optional_int32_extension) 1933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.Extensions[unittest_pb2.optional_int32_extension] = 0 1934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(first_proto, second_proto) 1935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.Extensions[unittest_pb2.optional_int32_extension] = 0 1936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that differences in cached values 1939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # don't matter if "has" bits are both false. 1940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllExtensions() 1941fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllExtensions() 1942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 1943fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 0, first_proto.Extensions[unittest_pb2.optional_int32_extension]) 1944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1947b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass MutualRecursionEqualityTest(unittest.TestCase): 1948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testEqualityWithMutualRecursion(self): 1950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestMutualRecursionA() 1951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestMutualRecursionA() 1952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.bb.a.bb.optional_int32 = 23 1954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertNotEqual(first_proto, second_proto) 1955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.bb.a.bb.optional_int32 = 23 1956fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 1957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1959b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass ByteSizeTest(unittest.TestCase): 1960fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1961fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def setUp(self): 1962fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 1963fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto = more_extensions_pb2.ExtendedMessage() 1964fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto = unittest_pb2.TestPackedTypes() 1965fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_extended_proto = unittest_pb2.TestPackedExtensions() 1966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1967fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def Size(self): 1968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return self.proto.ByteSize() 1969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testEmptyMessage(self): 1971fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.proto.ByteSize()) 1972fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1973a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testSizedOnKwargs(self): 1974a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # Use a separate message to ensure testing right after creation. 1975a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto = unittest_pb2.TestAllTypes() 1976a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, proto.ByteSize()) 1977a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto_kwargs = unittest_pb2.TestAllTypes(optional_int64 = 1) 1978a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # One byte for the tag, one to encode varint 1. 1979a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(2, proto_kwargs.ByteSize()) 1980a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1981fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testVarints(self): 1982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def Test(i, expected_varint_size): 1983fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.Clear() 1984fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_int64 = i 1985fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Add one to the varint size for the tag info 1986fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # for tag 1. 1987fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(expected_varint_size + 1, self.Size()) 1988fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(0, 1) 1989fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(1, 1) 1990fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for i, num_bytes in zip(range(7, 63, 7), range(1, 10000)): 1991fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test((1 << i) - 1, num_bytes) 1992fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(-1, 10) 1993fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(-2, 10) 1994fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Test(-(1 << 63), 10) 1995fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1996fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testStrings(self): 1997fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_string = '' 1998fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Need one byte for tag info (tag #14), and one byte for length. 1999fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, self.Size()) 2000fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2001fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_string = 'abc' 2002fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Need one byte for tag info (tag #14), and one byte for length. 2003fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + len(self.proto.optional_string), self.Size()) 2004fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_string = 'x' * 128 2006fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Need one byte for tag info (tag #14), and TWO bytes for length. 2007fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3 + len(self.proto.optional_string), self.Size()) 2008fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2009fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testOtherNumerics(self): 2010fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_fixed32 = 1234 2011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # One byte for tag and 4 bytes for fixed32. 2012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, self.Size()) 2013fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 2014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2015fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_fixed64 = 1234 2016fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # One byte for tag and 8 bytes for fixed64. 2017fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(9, self.Size()) 2018fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 2019fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2020fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_float = 1.234 2021fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # One byte for tag and 4 bytes for float. 2022fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, self.Size()) 2023fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 2024fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2025fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_double = 1.234 2026fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # One byte for tag and 8 bytes for float. 2027fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(9, self.Size()) 2028fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 2029fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2030fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_sint32 = 64 2031fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # One byte for tag and 2 bytes for zig-zag-encoded 64. 2032fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.Size()) 2033fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto = unittest_pb2.TestAllTypes() 2034fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2035fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testComposites(self): 2036fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 3 bytes. 2037fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_nested_message.bb = (1 << 14) 2038fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Plus one byte for bb tag. 2039fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Plus 1 byte for optional_nested_message serialized size. 2040fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Plus two bytes for optional_nested_message tag. 2041fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3 + 1 + 1 + 2, self.Size()) 2042fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2043fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testGroups(self): 2044fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 4 bytes. 2045fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optionalgroup.a = (1 << 21) 2046fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Plus two bytes for |a| tag. 2047fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Plus 2 * two bytes for START_GROUP and END_GROUP tags. 2048fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4 + 2 + 2*2, self.Size()) 2049fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2050fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalars(self): 2051fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(10) # 1 byte. 2052fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(128) # 2 bytes. 2053fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Also need 2 bytes for each entry for tag. 2054fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1 + 2 + 2*2, self.Size()) 2055fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2056fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalarsExtend(self): 2057fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.extend([10, 128]) # 3 bytes. 2058fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Also need 2 bytes for each entry for tag. 2059fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1 + 2 + 2*2, self.Size()) 2060fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2061fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedScalarsRemove(self): 2062fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(10) # 1 byte. 2063fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(128) # 2 bytes. 2064fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Also need 2 bytes for each entry for tag. 2065fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1 + 2 + 2*2, self.Size()) 2066fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.remove(128) 2067fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1 + 2, self.Size()) 2068fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2069fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedComposites(self): 2070fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Empty message. 2 bytes tag plus 1 byte length. 2071fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_0 = self.proto.repeated_nested_message.add() 2072fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2073fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_1 = self.proto.repeated_nested_message.add() 2074fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_1.bb = 7 2075fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 1 + 2 + 1 + 1 + 1, self.Size()) 2076fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2077fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedCompositesDelete(self): 2078fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Empty message. 2 bytes tag plus 1 byte length. 2079fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_0 = self.proto.repeated_nested_message.add() 2080fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2081fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_1 = self.proto.repeated_nested_message.add() 2082fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_1.bb = 9 2083fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 1 + 2 + 1 + 1 + 1, self.Size()) 2084fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2085fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2086fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del self.proto.repeated_nested_message[0] 2087fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 1 + 1 + 1, self.Size()) 2088fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2089fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Now add a new message. 2090fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_2 = self.proto.repeated_nested_message.add() 2091fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville foreign_message_2.bb = 12 2092fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2093fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2094fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 1 + 1 + 1 + 2 + 1 + 1 + 1, self.Size()) 2096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 bytes tag plus 1 byte length plus 1 byte bb tag 1 byte int. 2098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del self.proto.repeated_nested_message[1] 2099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 1 + 1 + 1, self.Size()) 2100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville del self.proto.repeated_nested_message[0] 2102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.Size()) 2103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testRepeatedGroups(self): 2105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2-byte START_GROUP plus 2-byte END_GROUP. 2106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group_0 = self.proto.repeatedgroup.add() 2107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2-byte START_GROUP plus 2-byte |a| tag + 1-byte |a| 2108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # plus 2-byte END_GROUP. 2109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group_1 = self.proto.repeatedgroup.add() 2110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville group_1.a = 7 2111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2 + 2 + 2 + 2 + 1 + 2, self.Size()) 2112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testExtensions(self): 2114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllExtensions() 2115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, proto.ByteSize()) 2116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = unittest_pb2.optional_int32_extension # Field #1, 1 byte. 2117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension] = 23 2118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 1 byte for tag, 1 byte for value. 2119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto.ByteSize()) 2120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCacheInvalidationForNonrepeatedScalar(self): 2122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test non-extension. 2123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_int32 = 1 2124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, self.proto.ByteSize()) 2125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_int32 = 128 2126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.proto.ByteSize()) 2127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.ClearField('optional_int32') 2128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.proto.ByteSize()) 2129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test within extension. 2131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = more_extensions_pb2.optional_int_extension 2132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.Extensions[extension] = 1 2133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, self.extended_proto.ByteSize()) 2134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.Extensions[extension] = 128 2135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.extended_proto.ByteSize()) 2136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.ClearExtension(extension) 2137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.extended_proto.ByteSize()) 2138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCacheInvalidationForRepeatedScalar(self): 2140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test non-extension. 2141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(1) 2142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.proto.ByteSize()) 2143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32.append(1) 2144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(6, self.proto.ByteSize()) 2145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_int32[1] = 128 2146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(7, self.proto.ByteSize()) 2147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.ClearField('repeated_int32') 2148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.proto.ByteSize()) 2149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test within extension. 2151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = more_extensions_pb2.repeated_int_extension 2152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeated = self.extended_proto.Extensions[extension] 2153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeated.append(1) 2154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, self.extended_proto.ByteSize()) 2155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeated.append(1) 2156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, self.extended_proto.ByteSize()) 2157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeated[1] = 128 2158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, self.extended_proto.ByteSize()) 2159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.ClearExtension(extension) 2160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.extended_proto.ByteSize()) 2161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCacheInvalidationForNonrepeatedMessage(self): 2163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test non-extension. 2164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_foreign_message.c = 1 2165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, self.proto.ByteSize()) 2166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_foreign_message.c = 128 2167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(6, self.proto.ByteSize()) 2168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.optional_foreign_message.ClearField('c') 2169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.proto.ByteSize()) 2170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.ClearField('optional_foreign_message') 2171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.proto.ByteSize()) 2172a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2173a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() == 'python': 2174a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # This is only possible in pure-Python implementation of the API. 2175a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson child = self.proto.optional_foreign_message 2176a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.proto.ClearField('optional_foreign_message') 2177a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson child.c = 128 2178a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(0, self.proto.ByteSize()) 2179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test within extension. 2181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = more_extensions_pb2.optional_message_extension 2182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child = self.extended_proto.Extensions[extension] 2183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.extended_proto.ByteSize()) 2184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child.foreign_message_int = 1 2185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, self.extended_proto.ByteSize()) 2186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child.foreign_message_int = 128 2187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, self.extended_proto.ByteSize()) 2188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.ClearExtension(extension) 2189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.extended_proto.ByteSize()) 2190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCacheInvalidationForRepeatedMessage(self): 2192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test non-extension. 2193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child0 = self.proto.repeated_foreign_message.add() 2194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, self.proto.ByteSize()) 2195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.repeated_foreign_message.add() 2196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(6, self.proto.ByteSize()) 2197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child0.c = 1 2198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(8, self.proto.ByteSize()) 2199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.proto.ClearField('repeated_foreign_message') 2200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.proto.ByteSize()) 2201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Test within extension. 2203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = more_extensions_pb2.repeated_message_extension 2204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child_list = self.extended_proto.Extensions[extension] 2205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child0 = child_list.add() 2206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, self.extended_proto.ByteSize()) 2207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child_list.add() 2208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, self.extended_proto.ByteSize()) 2209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child0.foreign_message_int = 1 2210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(6, self.extended_proto.ByteSize()) 2211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville child0.ClearField('foreign_message_int') 2212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, self.extended_proto.ByteSize()) 2213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.extended_proto.ClearExtension(extension) 2214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.extended_proto.ByteSize()) 2215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testPackedRepeatedScalars(self): 2217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.packed_proto.ByteSize()) 2218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto.packed_int32.append(10) # 1 byte. 2220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto.packed_int32.append(128) # 2 bytes. 2221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # The tag is 2 bytes (the field number is 90), and the varint 2222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # storing the length is 1 byte. 2223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int_size = 1 + 2 + 3 2224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(int_size, self.packed_proto.ByteSize()) 2225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto.packed_double.append(4.2) # 8 bytes 2227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto.packed_double.append(3.25) # 8 bytes 2228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # 2 more tag bytes, 1 more length byte. 2229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville double_size = 8 + 8 + 3 2230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(int_size+double_size, self.packed_proto.ByteSize()) 2231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.packed_proto.ClearField('packed_int32') 2233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(double_size, self.packed_proto.ByteSize()) 2234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testPackedExtensions(self): 2236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(0, self.packed_extended_proto.ByteSize()) 2237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension = self.packed_extended_proto.Extensions[ 2238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.packed_fixed32_extension] 2239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension.extend([1, 2, 3, 4]) # 16 bytes 2240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Tag is 3 bytes. 2241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(19, self.packed_extended_proto.ByteSize()) 2242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# Issues to be sure to cover include: 2245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Handling of unrecognized tags ("uninterpreted_bytes"). 2246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Handling of MessageSets. 2247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Consistent ordering of tags in the wire format, 2248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# including ordering between extensions and non-extension 2249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# fields. 2250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Consistent serialization of negative numbers, especially 2251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# negative int32s. 2252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# * Handling of empty submessages (with and without "has" 2253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville# bits set). 2254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2255b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass SerializationTest(unittest.TestCase): 2256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeEmtpyMessage(self): 2258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllTypes() 2259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllTypes() 2260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto.ByteSize(), len(serialized)) 2262a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2263a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2264a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto.MergeFromString(serialized)) 2265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 2266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeAllFields(self): 2268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllTypes() 2269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllTypes() 2270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(first_proto) 2271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto.ByteSize(), len(serialized)) 2273a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2274a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2275a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto.MergeFromString(serialized)) 2276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 2277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeAllExtensions(self): 2279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllExtensions() 2280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllExtensions() 2281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllExtensions(first_proto) 2282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2283a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2284a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2285a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto.MergeFromString(serialized)) 2286a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(first_proto, second_proto) 2287a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2288a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testSerializeWithOptionalGroup(self): 2289a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson first_proto = unittest_pb2.TestAllTypes() 2290a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto = unittest_pb2.TestAllTypes() 2291a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson first_proto.optionalgroup.a = 242 2292a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized = first_proto.SerializeToString() 2293a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2294a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2295a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto.MergeFromString(serialized)) 2296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 2297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2298d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testSerializeNegativeValues(self): 2299d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto = unittest_pb2.TestAllTypes() 2300d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2301d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_int32 = -1 2302d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_int64 = -(2 << 40) 2303d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_sint32 = -3 2304d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_sint64 = -(4 << 40) 2305d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_sfixed32 = -5 2306d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.optional_sfixed64 = -(6 << 40) 2307d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2308d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville second_proto = unittest_pb2.TestAllTypes.FromString( 2309d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto.SerializeToString()) 2310d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2311d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(first_proto, second_proto) 2312d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2313d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testParseTruncated(self): 2314a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # This test is only applicable for the Python implementation of the API. 2315a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if api_implementation.Type() != 'python': 2316a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return 2317a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2318d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville first_proto = unittest_pb2.TestAllTypes() 2319d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville test_util.SetAllFields(first_proto) 2320d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville serialized = first_proto.SerializeToString() 2321d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2322b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer for truncation_point in range(len(serialized) + 1): 2323d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville try: 2324d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville second_proto = unittest_pb2.TestAllTypes() 2325d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unknown_fields = unittest_pb2.TestEmptyMessage() 2326d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville pos = second_proto._InternalParse(serialized, 0, truncation_point) 2327d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # If we didn't raise an error then we read exactly the amount expected. 2328d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(truncation_point, pos) 2329d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2330d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Parsing to unknown fields should not throw if parsing to known fields 2331d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # did not. 2332d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville try: 2333d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville pos2 = unknown_fields._InternalParse(serialized, 0, truncation_point) 2334d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(truncation_point, pos2) 2335d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville except message.DecodeError: 2336d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.fail('Parsing unknown fields failed when parsing known fields ' 2337d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 'did not.') 2338d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville except message.DecodeError: 2339d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Parsing unknown fields should also fail. 2340d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertRaises(message.DecodeError, unknown_fields._InternalParse, 2341d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville serialized, 0, truncation_point) 2342d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCanonicalSerializationOrder(self): 2344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = more_messages_pb2.OutOfOrderFields() 2345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # These are also their tag numbers. Even though we're setting these in 2346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # reverse-tag order AND they're listed in reverse tag-order in the .proto 2347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # file, they should nonetheless be serialized in tag order. 2348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_sint32 = 5 2349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[more_messages_pb2.optional_uint64] = 4 2350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_uint32 = 3 2351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[more_messages_pb2.optional_int64] = 2 2352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 1 2353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto.ByteSize(), len(serialized)) 2355d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville d = _MiniDecoder(serialized) 2356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ReadTag = d.ReadFieldNumberAndWireType 2357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((1, wire_format.WIRETYPE_VARINT), ReadTag()) 2358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, d.ReadInt32()) 2359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((2, wire_format.WIRETYPE_VARINT), ReadTag()) 2360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, d.ReadInt64()) 2361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((3, wire_format.WIRETYPE_VARINT), ReadTag()) 2362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, d.ReadUInt32()) 2363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((4, wire_format.WIRETYPE_VARINT), ReadTag()) 2364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, d.ReadUInt64()) 2365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((5, wire_format.WIRETYPE_VARINT), ReadTag()) 2366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(5, d.ReadSInt32()) 2367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testCanonicalSerializationOrderSameAsCpp(self): 2369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Copy of the same test we use for C++. 2370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestFieldOrderings() 2371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFieldsAndExtensions(proto) 2372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.ExpectAllFieldsAndExtensionsInOrder(serialized) 2374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergeFromStringWhenFieldsAlreadySet(self): 2376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestAllTypes() 2377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.repeated_string.append('foobar') 2378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.optional_int32 = 23 2379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.optional_nested_message.bb = 42 2380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestAllTypes() 2383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.repeated_string.append('baz') 2384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.optional_int32 = 100 2385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.optional_nested_message.bb = 999 2386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2387a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bytes_parsed = second_proto.MergeFromString(serialized) 2388a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(len(serialized), bytes_parsed) 2389a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we append to repeated fields. 2391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(['baz', 'foobar'], list(second_proto.repeated_string)) 2392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we overwrite nonrepeatd scalars. 2393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(23, second_proto.optional_int32) 2394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Ensure that we recursively call MergeFromString() on 2395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # submessages. 2396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(42, second_proto.optional_nested_message.bb) 2397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMessageSetWireFormat(self): 2399b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto = message_set_extensions_pb2.TestMessageSet() 2400b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message1 = message_set_extensions_pb2.TestMessageSetExtension1 2401b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message2 = message_set_extensions_pb2.TestMessageSetExtension2 2402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension1 = extension_message1.message_set_extension 2403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension2 = extension_message2.message_set_extension 2404b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension3 = message_set_extensions_pb2.message_set_extension3 2405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension1].i = 123 2406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.Extensions[extension2].str = 'foo' 2407b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto.Extensions[extension3].text = 'bar' 2408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Serialize using the MessageSet wire format (this is specified in the 2410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # .proto file). 2411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raw = unittest_mset_pb2.RawMessageSet() 2414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(False, 2415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raw.DESCRIPTOR.GetOptions().message_set_wire_format) 2416a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2417a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2418a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson raw.MergeFromString(serialized)) 2419b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(3, len(raw.item)) 2420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2421b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message1 = message_set_extensions_pb2.TestMessageSetExtension1() 2422a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2423a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(raw.item[0].message), 2424a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message1.MergeFromString(raw.item[0].message)) 2425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(123, message1.i) 2426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2427b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message2 = message_set_extensions_pb2.TestMessageSetExtension2() 2428a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2429a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(raw.item[1].message), 2430a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message2.MergeFromString(raw.item[1].message)) 2431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('foo', message2.str) 2432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2433b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message3 = message_set_extensions_pb2.TestMessageSetExtension3() 2434b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual( 2435b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer len(raw.item[2].message), 2436b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message3.MergeFromString(raw.item[2].message)) 2437b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual('bar', message3.text) 2438b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 2439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Deserialize using the MessageSet wire format. 2440b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto2 = message_set_extensions_pb2.TestMessageSet() 2441a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2442a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2443a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(serialized)) 2444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(123, proto2.Extensions[extension1].i) 2445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('foo', proto2.Extensions[extension2].str) 2446b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual('bar', proto2.Extensions[extension3].text) 2447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check byte size. 2449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto2.ByteSize(), len(serialized)) 2450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto.ByteSize(), len(serialized)) 2451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMessageSetWireFormatUnknownExtension(self): 2453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Create a message using the message set wire format with an unknown 2454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # message. 2455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raw = unittest_mset_pb2.RawMessageSet() 2456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Add an item. 2458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item = raw.item.add() 2459b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer item.type_id = 98418603 2460b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message1 = message_set_extensions_pb2.TestMessageSetExtension1 2461b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message1 = message_set_extensions_pb2.TestMessageSetExtension1() 2462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.i = 12345 2463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item.message = message1.SerializeToString() 2464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Add a second, unknown extension. 2466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item = raw.item.add() 2467b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer item.type_id = 98418604 2468b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message1 = message_set_extensions_pb2.TestMessageSetExtension1 2469b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message1 = message_set_extensions_pb2.TestMessageSetExtension1() 2470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.i = 12346 2471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item.message = message1.SerializeToString() 2472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Add another unknown extension. 2474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item = raw.item.add() 2475b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer item.type_id = 98418605 2476b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer message1 = message_set_extensions_pb2.TestMessageSetExtension2() 2477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message1.str = 'foo' 2478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville item.message = message1.SerializeToString() 2479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = raw.SerializeToString() 2481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Parse message using the message set wire format. 2483b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto = message_set_extensions_pb2.TestMessageSet() 2484a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2485a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2486a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto.MergeFromString(serialized)) 2487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check that the message parsed well. 2489b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer extension_message1 = message_set_extensions_pb2.TestMessageSetExtension1 2490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extension1 = extension_message1.message_set_extension 2491b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(12345, proto.Extensions[extension1].i) 2492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testUnknownFields(self): 2494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 2495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllFields(proto) 2496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # The empty message should be parsable with all of the fields 2500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # unknown. 2501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestEmptyMessage() 2502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Parsing this message should succeed. 2504a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2505a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2506a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(serialized)) 2507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Now test with a int64 field set. 2509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 2510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int64 = 0x0fffffffffffffff 2511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # The empty message should be parsable with all of the fields 2513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # unknown. 2514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestEmptyMessage() 2515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Parsing this message should succeed. 2516a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2517a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2518a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(serialized)) 2519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def _CheckRaises(self, exc_class, callable_obj, exception): 2521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville """This method checks if the excpetion type and message are as expected.""" 2522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville try: 2523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville callable_obj() 2524a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson except exc_class as ex: 2525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Check if the exception message is the right one. 2526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(exception, str(ex)) 2527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return 2528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville else: 2529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville raise self.failureException('%s not raised' % str(exc_class)) 2530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeUninitialized(self): 2532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestRequired() 2533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self._CheckRaises( 2534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message.EncodeError, 2535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.SerializeToString, 2536a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Message protobuf_unittest.TestRequired is missing required fields: ' 2537a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'a,b,c') 2538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't raise exceptions. 2539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville partial = proto.SerializePartialToString() 2540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2541a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2 = unittest_pb2.TestRequired() 2542a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto2.HasField('a')) 2543a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson # proto2 ParseFromString does not check that required fields are set. 2544a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.ParseFromString(partial) 2545a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertFalse(proto2.HasField('a')) 2546a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.a = 1 2548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self._CheckRaises( 2549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message.EncodeError, 2550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.SerializeToString, 2551a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Message protobuf_unittest.TestRequired is missing required fields: b,c') 2552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't raise exceptions. 2553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville partial = proto.SerializePartialToString() 2554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.b = 2 2556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self._CheckRaises( 2557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville message.EncodeError, 2558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.SerializeToString, 2559a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Message protobuf_unittest.TestRequired is missing required fields: c') 2560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't raise exceptions. 2561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville partial = proto.SerializePartialToString() 2562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.c = 3 2564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville # Shouldn't raise exceptions. 2566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville partial = proto.SerializePartialToString() 2567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto2 = unittest_pb2.TestRequired() 2569a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2570a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2571a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(serialized)) 2572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.a) 2573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto2.b) 2574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, proto2.c) 2575a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2576a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(partial), 2577a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson proto2.MergeFromString(partial)) 2578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto2.a) 2579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto2.b) 2580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, proto2.c) 2581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2582d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testSerializeUninitializedSubMessage(self): 2583d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto = unittest_pb2.TestRequiredForeign() 2584d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2585d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville # Sub-message doesn't exist yet, so this succeeds. 2586d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString() 2587d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2588d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_message.a = 1 2589d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._CheckRaises( 2590d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville message.EncodeError, 2591d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString, 2592a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Message protobuf_unittest.TestRequiredForeign ' 2593a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'is missing required fields: ' 2594d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 'optional_message.b,optional_message.c') 2595d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2596d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_message.b = 2 2597d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.optional_message.c = 3 2598d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString() 2599d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2600d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message.add().a = 1 2601d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message.add().b = 2 2602d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self._CheckRaises( 2603d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville message.EncodeError, 2604d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString, 2605a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'Message protobuf_unittest.TestRequiredForeign is missing required fields: ' 2606d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 'repeated_message[0].b,repeated_message[0].c,' 2607d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 'repeated_message[1].a,repeated_message[1].c') 2608d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2609d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message[0].b = 2 2610d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message[0].c = 3 2611d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message[1].a = 1 2612d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.repeated_message[1].c = 3 2613d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville proto.SerializeToString() 2614d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeAllPackedFields(self): 2616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestPackedTypes() 2617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestPackedTypes() 2618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllPackedFields(first_proto) 2619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto.ByteSize(), len(serialized)) 2621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bytes_read = second_proto.MergeFromString(serialized) 2622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(second_proto.ByteSize(), bytes_read) 2623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 2624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testSerializeAllPackedExtensions(self): 2626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestPackedExtensions() 2627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestPackedExtensions() 2628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_util.SetAllPackedExtensions(first_proto) 2629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bytes_read = second_proto.MergeFromString(serialized) 2631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(second_proto.ByteSize(), bytes_read) 2632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(first_proto, second_proto) 2633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMergePackedFromStringWhenSomeFieldsAlreadySet(self): 2635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto = unittest_pb2.TestPackedTypes() 2636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.packed_int32.extend([1, 2]) 2637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville first_proto.packed_double.append(3.0) 2638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = first_proto.SerializeToString() 2639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto = unittest_pb2.TestPackedTypes() 2641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.packed_int32.append(3) 2642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.packed_double.extend([1.0, 2.0]) 2643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville second_proto.packed_sint32.append(4) 2644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2645a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2646a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2647a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson second_proto.MergeFromString(serialized)) 2648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([3, 1, 2], second_proto.packed_int32) 2649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([1.0, 2.0, 3.0], second_proto.packed_double) 2650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([4], second_proto.packed_sint32) 2651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testPackedFieldsWireFormat(self): 2653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestPackedTypes() 2654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.packed_int32.extend([1, 2, 150, 3]) # 1 + 1 + 2 + 1 bytes 2655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.packed_double.extend([1.0, 1000.0]) # 8 + 8 bytes 2656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.packed_float.append(2.0) # 4 bytes, will be before double 2657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville serialized = proto.SerializeToString() 2658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(proto.ByteSize(), len(serialized)) 2659d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville d = _MiniDecoder(serialized) 2660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ReadTag = d.ReadFieldNumberAndWireType 2661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((90, wire_format.WIRETYPE_LENGTH_DELIMITED), ReadTag()) 2662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1+1+1+2, d.ReadInt32()) 2663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, d.ReadInt32()) 2664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, d.ReadInt32()) 2665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(150, d.ReadInt32()) 2666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, d.ReadInt32()) 2667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((100, wire_format.WIRETYPE_LENGTH_DELIMITED), ReadTag()) 2668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(4, d.ReadInt32()) 2669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2.0, d.ReadFloat()) 2670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual((101, wire_format.WIRETYPE_LENGTH_DELIMITED), ReadTag()) 2671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(8+8, d.ReadInt32()) 2672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1.0, d.ReadDouble()) 2673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1000.0, d.ReadDouble()) 2674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(d.EndOfStream()) 2675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2676d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testParsePackedFromUnpacked(self): 2677d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unpacked = unittest_pb2.TestUnpackedTypes() 2678d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville test_util.SetAllUnpackedFields(unpacked) 2679d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville packed = unittest_pb2.TestPackedTypes() 2680a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized = unpacked.SerializeToString() 2681a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2682a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2683a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson packed.MergeFromString(serialized)) 2684d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville expected = unittest_pb2.TestPackedTypes() 2685d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville test_util.SetAllPackedFields(expected) 2686d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(expected, packed) 2687d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2688d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville def testParseUnpackedFromPacked(self): 2689d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville packed = unittest_pb2.TestPackedTypes() 2690d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville test_util.SetAllPackedFields(packed) 2691d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville unpacked = unittest_pb2.TestUnpackedTypes() 2692a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson serialized = packed.SerializeToString() 2693a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual( 2694a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson len(serialized), 2695a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson unpacked.MergeFromString(serialized)) 2696d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville expected = unittest_pb2.TestUnpackedTypes() 2697d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville test_util.SetAllUnpackedFields(expected) 2698d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville self.assertEqual(expected, unpacked) 2699d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 2700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testFieldNumbers(self): 2701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 2702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.NestedMessage.BB_FIELD_NUMBER, 1) 2703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.OPTIONAL_INT32_FIELD_NUMBER, 1) 2704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.OPTIONALGROUP_FIELD_NUMBER, 16) 2705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.TestAllTypes.OPTIONAL_NESTED_MESSAGE_FIELD_NUMBER, 18) 2707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.TestAllTypes.OPTIONAL_NESTED_ENUM_FIELD_NUMBER, 21) 2709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.REPEATED_INT32_FIELD_NUMBER, 31) 2710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.REPEATEDGROUP_FIELD_NUMBER, 46) 2711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.TestAllTypes.REPEATED_NESTED_MESSAGE_FIELD_NUMBER, 48) 2713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.TestAllTypes.REPEATED_NESTED_ENUM_FIELD_NUMBER, 51) 2715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testExtensionFieldNumbers(self): 2717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestRequired.single.number, 1000) 2718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestRequired.SINGLE_FIELD_NUMBER, 1000) 2719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestRequired.multi.number, 1001) 2720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestRequired.MULTI_FIELD_NUMBER, 1001) 2721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.optional_int32_extension.number, 1) 2722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.OPTIONAL_INT32_EXTENSION_FIELD_NUMBER, 1) 2723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.optionalgroup_extension.number, 16) 2724fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.OPTIONALGROUP_EXTENSION_FIELD_NUMBER, 16) 2725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.optional_nested_message_extension.number, 18) 2726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.OPTIONAL_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 18) 2728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.optional_nested_enum_extension.number, 21) 2729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.OPTIONAL_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 2730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 21) 2731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.repeated_int32_extension.number, 31) 2732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.REPEATED_INT32_EXTENSION_FIELD_NUMBER, 31) 2733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.repeatedgroup_extension.number, 46) 2734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.REPEATEDGROUP_EXTENSION_FIELD_NUMBER, 46) 2735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.repeated_nested_message_extension.number, 48) 2736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual( 2737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unittest_pb2.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48) 2738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.repeated_nested_enum_extension.number, 51) 2739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 2740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 51) 2741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testInitKwargs(self): 2743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes( 2744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_int32=1, 2745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_string='foo', 2746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_bool=True, 2747a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson optional_bytes=b'bar', 2748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_nested_message=unittest_pb2.TestAllTypes.NestedMessage(bb=1), 2749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_foreign_message=unittest_pb2.ForeignMessage(c=1), 2750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_nested_enum=unittest_pb2.TestAllTypes.FOO, 2751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_foreign_enum=unittest_pb2.FOREIGN_FOO, 2752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville repeated_int32=[1, 2, 3]) 2753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.IsInitialized()) 2754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_int32')) 2755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_string')) 2756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_bool')) 2757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_bytes')) 2758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_nested_message')) 2759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_foreign_message')) 2760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_nested_enum')) 2761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_foreign_enum')) 2762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_int32) 2763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual('foo', proto.optional_string) 2764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(True, proto.optional_bool) 2765a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(b'bar', proto.optional_bytes) 2766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_nested_message.bb) 2767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_foreign_message.c) 2768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestAllTypes.FOO, 2769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_nested_enum) 2770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.FOREIGN_FOO, proto.optional_foreign_enum) 2771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual([1, 2, 3], proto.repeated_int32) 2772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testInitArgsUnknownFieldName(self): 2774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def InitalizeEmptyMessageWithExtraKeywordArg(): 2775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville unused_proto = unittest_pb2.TestEmptyMessage(unknown='unknown') 2776b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self._CheckRaises( 2777b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer ValueError, 2778b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer InitalizeEmptyMessageWithExtraKeywordArg, 2779b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 'Protocol message TestEmptyMessage has no "unknown" field.') 2780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testInitRequiredKwargs(self): 2782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestRequired(a=1, b=1, c=1) 2783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.IsInitialized()) 2784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('a')) 2785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('b')) 2786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('c')) 2787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.HasField('dummy2')) 2788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.a) 2789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.b) 2790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.c) 2791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testInitRequiredForeignKwargs(self): 2793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestRequiredForeign( 2794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville optional_message=unittest_pb2.TestRequired(a=1, b=1, c=1)) 2795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.IsInitialized()) 2796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.HasField('optional_message')) 2797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.optional_message.IsInitialized()) 2798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.optional_message.HasField('a')) 2799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.optional_message.HasField('b')) 2800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.optional_message.HasField('c')) 2801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(not proto.optional_message.HasField('dummy2')) 2802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(unittest_pb2.TestRequired(a=1, b=1, c=1), 2803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_message) 2804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_message.a) 2805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_message.b) 2806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.optional_message.c) 2807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testInitRepeatedKwargs(self): 2809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes(repeated_int32=[1, 2, 3]) 2810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertTrue(proto.IsInitialized()) 2811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(1, proto.repeated_int32[0]) 2812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(2, proto.repeated_int32[1]) 2813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(3, proto.repeated_int32[2]) 2814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2816b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass OptionsTest(unittest.TestCase): 2817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2818fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testMessageOptions(self): 2819b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer proto = message_set_extensions_pb2.TestMessageSet() 2820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(True, 2821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.DESCRIPTOR.GetOptions().message_set_wire_format) 2822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 2823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(False, 2824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.DESCRIPTOR.GetOptions().message_set_wire_format) 2825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville def testPackedOptions(self): 2827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestAllTypes() 2828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_int32 = 1 2829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.optional_double = 3.0 2830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for field_descriptor, _ in proto.ListFields(): 2831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(False, field_descriptor.GetOptions().packed) 2832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto = unittest_pb2.TestPackedTypes() 2834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.packed_int32.append(1) 2835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville proto.packed_double.append(3.0) 2836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for field_descriptor, _ in proto.ListFields(): 2837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville self.assertEqual(True, field_descriptor.GetOptions().packed) 2838b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer self.assertEqual(descriptor.FieldDescriptor.LABEL_REPEATED, 2839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville field_descriptor.label) 2840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 2843b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammerclass ClassAPITest(unittest.TestCase): 2844a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2845b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer @unittest.skipIf( 2846b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer api_implementation.Type() == 'cpp' and api_implementation.Version() == 2, 2847b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer 'C++ implementation requires a call to MakeDescriptor()') 2848a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testMakeClassWithNestedDescriptor(self): 2849a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson leaf_desc = descriptor.Descriptor('leaf', 'package.parent.child.leaf', '', 2850a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson containing_type=None, fields=[], 2851a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested_types=[], enum_types=[], 2852a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson extensions=[]) 2853a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson child_desc = descriptor.Descriptor('child', 'package.parent.child', '', 2854a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson containing_type=None, fields=[], 2855a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested_types=[leaf_desc], enum_types=[], 2856a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson extensions=[]) 2857a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson sibling_desc = descriptor.Descriptor('sibling', 'package.parent.sibling', 2858a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson '', containing_type=None, fields=[], 2859a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested_types=[], enum_types=[], 2860a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson extensions=[]) 2861a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson parent_desc = descriptor.Descriptor('parent', 'package.parent', '', 2862a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson containing_type=None, fields=[], 2863a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson nested_types=[child_desc, sibling_desc], 2864a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson enum_types=[], extensions=[]) 2865a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson message_class = reflection.MakeClass(parent_desc) 2866a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertIn('child', message_class.__dict__) 2867a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertIn('sibling', message_class.__dict__) 2868a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertIn('leaf', message_class.child.__dict__) 2869a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2870a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def _GetSerializedFileDescriptor(self, name): 2871a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson """Get a serialized representation of a test FileDescriptorProto. 2872a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2873a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson Args: 2874a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson name: All calls to this must use a unique message name, to avoid 2875a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson collisions in the cpp descriptor pool. 2876a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson Returns: 2877a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson A string containing the serialized form of a test FileDescriptorProto. 2878a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson """ 2879a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor_str = ( 2880a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'message_type {' 2881a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "' + name + '"' 2882a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' field {' 2883a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "flat"' 2884a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' number: 1' 2885a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' label: LABEL_REPEATED' 2886a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type: TYPE_UINT32' 2887a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2888a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' field {' 2889a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "bar"' 2890a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' number: 2' 2891a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' label: LABEL_OPTIONAL' 2892a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type: TYPE_MESSAGE' 2893a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type_name: "Bar"' 2894a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2895a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' nested_type {' 2896a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "Bar"' 2897a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' field {' 2898a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "baz"' 2899a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' number: 3' 2900a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' label: LABEL_OPTIONAL' 2901a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type: TYPE_MESSAGE' 2902a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type_name: "Baz"' 2903a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2904a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' nested_type {' 2905a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "Baz"' 2906a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' enum_type {' 2907a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "deep_enum"' 2908a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' value {' 2909a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "VALUE_A"' 2910a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' number: 0' 2911a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2912a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2913a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' field {' 2914a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' name: "deep"' 2915a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' number: 4' 2916a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' label: LABEL_OPTIONAL' 2917a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' type: TYPE_UINT32' 2918a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2919a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2920a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2921a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson '}') 2922a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor = descriptor_pb2.FileDescriptorProto() 2923a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson text_format.Merge(file_descriptor_str, file_descriptor) 2924a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return file_descriptor.SerializeToString() 2925a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2926a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testParsingFlatClassWithExplicitClassDeclaration(self): 2927a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson """Test that the generated class can parse a flat message.""" 2928b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # TODO(xiaofeng): This test fails with cpp implemetnation in the call 2929b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # of six.with_metaclass(). The other two callsites of with_metaclass 2930b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # in this file are both excluded from cpp test, so it might be expected 2931b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # to fail. Need someone more familiar with the python code to take a 2932b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer # look at this. 2933b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer if api_implementation.Type() != 'python': 2934b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer return 2935a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor = descriptor_pb2.FileDescriptorProto() 2936a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('A')) 2937a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_descriptor = descriptor.MakeDescriptor( 2938a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.message_type[0]) 2939a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2940b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer class MessageClass(six.with_metaclass(reflection.GeneratedProtocolMessageType, message.Message)): 2941a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson DESCRIPTOR = msg_descriptor 2942a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg = MessageClass() 2943a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_str = ( 2944a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 0 ' 2945a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 1 ' 2946a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 2 ') 2947a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson text_format.Merge(msg_str, msg) 2948a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(msg.flat, [0, 1, 2]) 2949a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2950a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testParsingFlatClass(self): 2951a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson """Test that the generated class can parse a flat message.""" 2952a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor = descriptor_pb2.FileDescriptorProto() 2953a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('B')) 2954a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_descriptor = descriptor.MakeDescriptor( 2955a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.message_type[0]) 2956a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_class = reflection.MakeClass(msg_descriptor) 2957a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg = msg_class() 2958a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_str = ( 2959a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 0 ' 2960a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 1 ' 2961a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'flat: 2 ') 2962a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson text_format.Merge(msg_str, msg) 2963a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(msg.flat, [0, 1, 2]) 2964a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2965a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson def testParsingNestedClass(self): 2966a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson """Test that the generated class can parse a nested message.""" 2967a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor = descriptor_pb2.FileDescriptorProto() 2968a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.ParseFromString(self._GetSerializedFileDescriptor('C')) 2969a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_descriptor = descriptor.MakeDescriptor( 2970a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson file_descriptor.message_type[0]) 2971a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_class = reflection.MakeClass(msg_descriptor) 2972a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg = msg_class() 2973a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson msg_str = ( 2974a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 'bar {' 2975a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' baz {' 2976a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' deep: 4' 2977a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson ' }' 2978a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson '}') 2979a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson text_format.Merge(msg_str, msg) 2980a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson self.assertEqual(msg.bar.baz.deep, 4) 2981a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 2982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleif __name__ == '__main__': 2983b0575e93e4c39dec69365b850088a1eb7f82c5b3Tamas Berghammer unittest.main() 2984