def testnotanumber(self): golden_data = ( "\x5d\x00\x00\xc0\x7f" "\x61\x00\x00\x00\x00\x00\x00\xf8\x7f" "\xcd\x02\x00\x00\xc0\x7f" "\xd1\x02\x00\x00\x00\x00\x00\x00\xf8\x7f" ) golden_message = unittest_pb2.testalltypes() golden_message.parsefromstring(golden_data) self.asserttrue(isnan(golden_message.optional_float)) self.asserttrue(isnan(golden_message.optional_double)) self.asserttrue(isnan(golden_message.repeated_float[0])) self.asserttrue(isnan(golden_message.repeated_double[0])) # the protocol buffer may serialize to any one of multiple different # representations of a nan. rather than verify a specific representation, # verify the serialized string can be converted into a correctly # behaving protocol buffer. serialized = golden_message.serializetostring() message = unittest_pb2.testalltypes() message.parsefromstring(serialized) self.asserttrue(isnan(message.optional_float)) self.asserttrue(isnan(message.optional_double)) self.asserttrue(isnan(message.repeated_float[0])) self.asserttrue(isnan(message.repeated_double[0]))
def testmergegolden(self): golden_text = '\n'.join(self.readgolden('text_format_unittest_data.txt')) parsed_message = unittest_pb2.testalltypes() text_format.merge(golden_text, parsed_message) message = unittest_pb2.testalltypes() test_util.setallfields(message) self.assertequals(message, parsed_message)
def testprintrawutf8string(self): message = unittest_pb2.testalltypes() message.repeated_string.append(u'\u00fc\ua71f') text = text_format.messagetostring(message, as_utf8 = true) self.comparetogoldentext(text, 'repeated_string: "\303\274\352\234\237"\n') parsed_message = unittest_pb2.testalltypes() text_format.merge(text, parsed_message) self.assertequals(message, parsed_message)
def testmergeallfields(self): message = unittest_pb2.testalltypes() test_util.setallfields(message) ascii_text = text_format.messagetostring(message) parsed_message = unittest_pb2.testalltypes() text_format.merge(ascii_text, parsed_message) self.assertequal(message, parsed_message) test_util.expectallfieldsset(self, message)
def testmergeemptygroup(self): message = unittest_pb2.testalltypes() text = 'optionalgroup: {}' text_format.merge(text, message) self.asserttrue(message.hasfield('optionalgroup')) message.clear() message = unittest_pb2.testalltypes() text = 'optionalgroup: <>' text_format.merge(text, message) self.asserttrue(message.hasfield('optionalgroup'))
def testmergeexotic(self): message = unittest_pb2.testalltypes() text = ('repeated_int64: -9223372036854775808\n' 'repeated_uint64: 18446744073709551615\n' 'repeated_double: 123.456\n' 'repeated_double: 1.23e+22\n' 'repeated_double: 1.23e-18\n' 'repeated_string: \n' '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n' 'repeated_string: "foo" \'corge\' "grault"\n' 'repeated_string: "\\303\\274\\352\\234\\237"\n' 'repeated_string: "\\xc3\\xbc"\n' 'repeated_string: "\xc3\xbc"\n') text_format.merge(text, message) self.assertequal(-9223372036854775808, message.repeated_int64[0]) self.assertequal(18446744073709551615, message.repeated_uint64[0]) self.assertequal(123.456, message.repeated_double[0]) self.assertequal(1.23e22, message.repeated_double[1]) self.assertequal(1.23e-18, message.repeated_double[2]) self.assertequal( '\000\001\a\b\f\n\r\t\v\\\'"', message.repeated_string[0]) self.assertequal('foocorgegrault', message.repeated_string[1]) self.assertequal(u'\u00fc\ua71f', message.repeated_string[2]) self.assertequal(u'\u00fc', message.repeated_string[3])
def testmergebadintvalue(self): message = unittest_pb2.testalltypes() text = 'optional_int32: bork' self.assertraiseswithmessage( text_format.parseerror, ('1:17 : couldn\'t parse integer: bork'), text_format.merge, text, message)
def testrepeatedscalarfieldsortarguments(self): """check sorting a scalar field using list.sort() arguments.""" message = unittest_pb2.testalltypes() abs_cmp = lambda a, b: cmp(abs(a), abs(b)) message.repeated_int32.append(-3) message.repeated_int32.append(-2) message.repeated_int32.append(-1) message.repeated_int32.sort(key=abs) self.assertequal(list(message.repeated_int32), [-1, -2, -3]) message.repeated_int32.sort(key=abs, reverse=true) self.assertequal(list(message.repeated_int32), [-3, -2, -1]) message.repeated_int32.sort(sort_function=abs_cmp) self.assertequal(list(message.repeated_int32), [-1, -2, -3]) message.repeated_int32.sort(cmp=abs_cmp, reverse=true) self.assertequal(list(message.repeated_int32), [-3, -2, -1]) len_cmp = lambda a, b: cmp(len(a), len(b)) message.repeated_string.append("aaa") message.repeated_string.append("bb") message.repeated_string.append("c") message.repeated_string.sort(key=len) self.assertequal(list(message.repeated_string), ["c", "bb", "aaa"]) message.repeated_string.sort(key=len, reverse=true) self.assertequal(list(message.repeated_string), ["aaa", "bb", "c"]) message.repeated_string.sort(sort_function=len_cmp) self.assertequal(list(message.repeated_string), ["c", "bb", "aaa"]) message.repeated_string.sort(cmp=len_cmp, reverse=true) self.assertequal(list(message.repeated_string), ["aaa", "bb", "c"])
def testmergebadenumvalue(self): message = unittest_pb2.testalltypes() text = 'optional_nested_enum: barr' self.assertraiseswithmessage( text_format.parseerror, ('1:23 : enum type "protobuf_unittest.testalltypes.nestedenum" ' 'has no value named barr.'), text_format.merge, text, message) message = unittest_pb2.testalltypes() text = 'optional_nested_enum: 100' self.assertraiseswithmessage( text_format.parseerror, ('1:23 : enum type "protobuf_unittest.testalltypes.nestedenum" ' 'has no value with number 100.'), text_format.merge, text, message)
def testprintnestedmessageasoneline(self): message = unittest_pb2.testalltypes() msg = message.repeated_nested_message.add() msg.bb = 42; self.comparetogoldentext( text_format.messagetostring(message, as_one_line=true), 'repeated_nested_message { bb: 42 }')
def testgoldenmessage(self): golden_data = test_util.goldenfile("golden_message").read() golden_message = unittest_pb2.testalltypes() golden_message.parsefromstring(golden_data) test_util.expectallfieldsset(self, golden_message) self.assertequal(golden_data, golden_message.serializetostring()) golden_copy = copy.deepcopy(golden_message) self.assertequal(golden_data, golden_copy.serializetostring())
def testmergesingleword(self): message = unittest_pb2.testalltypes() text = 'foo' self.assertraiseswithmessage( text_format.parseerror, ('1:1 : message type "protobuf_unittest.testalltypes" has no field named ' '"foo".'), text_format.merge, text, message)
def testpicklesupport(self): golden_data = test_util.goldenfile("golden_message").read() golden_message = unittest_pb2.testalltypes() golden_message.parsefromstring(golden_data) pickled_message = pickle.dumps(golden_message) unpickled_message = pickle.loads(pickled_message) self.assertequals(unpickled_message, golden_message)
def setup(self): self.descriptor = unittest_pb2.testalltypes.descriptor self.all_fields = unittest_pb2.testalltypes() test_util.setallfields(self.all_fields) self.all_fields_data = self.all_fields.serializetostring() self.empty_message = unittest_pb2.testemptymessage() self.empty_message.parsefromstring(self.all_fields_data) self.unknown_fields = self.empty_message._unknown_fields
def testmergeunknownfield(self): message = unittest_pb2.testalltypes() text = 'unknown_field: 8\n' self.assertraiseswithmessage( text_format.parseerror, ('1:1 : message type "protobuf_unittest.testalltypes" has no field named ' '"unknown_field".'), text_format.merge, text, message)
def testprintbadenumvalue(self): message = unittest_pb2.testalltypes() message.optional_nested_enum = 100 message.optional_foreign_enum = 101 message.optional_import_enum = 102 self.comparetogoldentext( text_format.messagetostring(message), 'optional_nested_enum: 100\n' 'optional_foreign_enum: 101\n' 'optional_import_enum: 102\n')
def testprintrepeatedfieldsasoneline(self): message = unittest_pb2.testalltypes() message.repeated_int32.append(1) message.repeated_int32.append(1) message.repeated_int32.append(3) message.repeated_string.append("google") message.repeated_string.append("zurich") self.comparetogoldentext( text_format.messagetostring(message, as_one_line=true), 'repeated_int32: 1 repeated_int32: 1 repeated_int32: 3 ' 'repeated_string: "google" repeated_string: "zurich"')
def testpublicimports(self): # test public imports as embedded message. all_type_proto = unittest_pb2.testalltypes() self.assertequal(0, all_type_proto.optional_public_import_message.e) # publicimportmessage is actually defined in unittest_import_public_pb2 # module, and is public imported by unittest_import_pb2 module. public_import_proto = unittest_import_pb2.publicimportmessage() self.assertequal(0, public_import_proto.e) self.asserttrue(unittest_import_public_pb2.publicimportmessage is unittest_import_pb2.publicimportmessage)
def testmergegroupnotclosed(self): message = unittest_pb2.testalltypes() text = 'repeatedgroup: <' self.assertraiseswithmessage( text_format.parseerror, '1:16 : expected ">".', text_format.merge, text, message) text = 'repeatedgroup: {' self.assertraiseswithmessage( text_format.parseerror, '1:16 : expected "}".', text_format.merge, text, message)
def testparsingmerge(self): """check the merge behavior when a required or optional field appears multiple times in the input.""" messages = [unittest_pb2.testalltypes(), unittest_pb2.testalltypes(), unittest_pb2.testalltypes()] messages[0].optional_int32 = 1 messages[1].optional_int64 = 2 messages[2].optional_int32 = 3 messages[2].optional_string = "hello" merged_message = unittest_pb2.testalltypes() merged_message.optional_int32 = 3 merged_message.optional_int64 = 2 merged_message.optional_string = "hello" generator = unittest_pb2.testparsingmerge.repeatedfieldsgenerator() generator.field1.extend(messages) generator.field2.extend(messages) generator.field3.extend(messages) generator.ext1.extend(messages) generator.ext2.extend(messages) generator.group1.add().field1.mergefrom(messages[0]) generator.group1.add().field1.mergefrom(messages[1]) generator.group1.add().field1.mergefrom(messages[2]) generator.group2.add().field1.mergefrom(messages[0]) generator.group2.add().field1.mergefrom(messages[1]) generator.group2.add().field1.mergefrom(messages[2]) data = generator.serializetostring() parsing_merge = unittest_pb2.testparsingmerge() parsing_merge.parsefromstring(data) # required and optional fields should be merged. self.assertequal(parsing_merge.required_all_types, merged_message) self.assertequal(parsing_merge.optional_all_types, merged_message) self.assertequal(parsing_merge.optionalgroup.optional_group_all_types, merged_message) self.assertequal(parsing_merge.extensions[unittest_pb2.testparsingmerge.optional_ext], merged_message) # repeated fields should not be merged. self.assertequal(len(parsing_merge.repeated_all_types), 3) self.assertequal(len(parsing_merge.repeatedgroup), 3) self.assertequal(len(parsing_merge.extensions[unittest_pb2.testparsingmerge.repeated_ext]), 3)
def testmergebadextension(self): message = unittest_pb2.testallextensions() text = '[unknown_extension]: 8\n' self.assertraiseswithmessage( text_format.parseerror, '1:2 : extension "unknown_extension" not registered.', text_format.merge, text, message) message = unittest_pb2.testalltypes() self.assertraiseswithmessage( text_format.parseerror, ('1:2 : message type "protobuf_unittest.testalltypes" does not have ' 'extensions.'), text_format.merge, text, message)
def testnegativeinfinity(self): golden_data = ( "\x5d\x00\x00\x80\xff" "\x61\x00\x00\x00\x00\x00\x00\xf0\xff" "\xcd\x02\x00\x00\x80\xff" "\xd1\x02\x00\x00\x00\x00\x00\x00\xf0\xff" ) golden_message = unittest_pb2.testalltypes() golden_message.parsefromstring(golden_data) self.asserttrue(isneginf(golden_message.optional_float)) self.asserttrue(isneginf(golden_message.optional_double)) self.asserttrue(isneginf(golden_message.repeated_float[0])) self.asserttrue(isneginf(golden_message.repeated_double[0])) self.assertequal(golden_data, golden_message.serializetostring())
def testroundtripexoticasoneline(self): message = unittest_pb2.testalltypes() message.repeated_int64.append(-9223372036854775808) message.repeated_uint64.append(18446744073709551615) message.repeated_double.append(123.456) message.repeated_double.append(1.23e22) message.repeated_double.append(1.23e-18) message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"') message.repeated_string.append(u'\u00fc\ua71f') # test as_utf8 = false. wire_text = text_format.messagetostring( message, as_one_line=true, as_utf8=false) parsed_message = unittest_pb2.testalltypes() text_format.merge(wire_text, parsed_message) self.assertequals(message, parsed_message) # test as_utf8 = true. wire_text = text_format.messagetostring( message, as_one_line=true, as_utf8=true) parsed_message = unittest_pb2.testalltypes() text_format.merge(wire_text, parsed_message) self.assertequals(message, parsed_message)
def testenums(self): # we test only module-level enums here. # todo(robinson): examine descriptors directly to check # enum descriptor output. self.assertequal(4, unittest_pb2.foreign_foo) self.assertequal(5, unittest_pb2.foreign_bar) self.assertequal(6, unittest_pb2.foreign_baz) proto = unittest_pb2.testalltypes() self.assertequal(1, proto.foo) self.assertequal(1, unittest_pb2.testalltypes.foo) self.assertequal(2, proto.bar) self.assertequal(2, unittest_pb2.testalltypes.bar) self.assertequal(3, proto.baz) self.assertequal(3, unittest_pb2.testalltypes.baz)
def testmergefrom(self): message = unittest_pb2.testalltypes() message.optional_int32 = 1 message.optional_uint32 = 2 source = unittest_pb2.testemptymessage() source.parsefromstring(message.serializetostring()) message.clearfield('optional_int32') message.optional_int64 = 3 message.optional_uint32 = 4 destination = unittest_pb2.testemptymessage() destination.parsefromstring(message.serializetostring()) unknown_fields = destination._unknown_fields[:] destination.mergefrom(source) self.assertequal(unknown_fields + source._unknown_fields, destination._unknown_fields)
def testsortingrepeatedcompositefieldscustomcomparator(self): """check passing a custom comparator to sort a repeated composite field.""" message = unittest_pb2.testalltypes() message.repeated_nested_message.add().bb = 1 message.repeated_nested_message.add().bb = 3 message.repeated_nested_message.add().bb = 2 message.repeated_nested_message.add().bb = 6 message.repeated_nested_message.add().bb = 5 message.repeated_nested_message.add().bb = 4 message.repeated_nested_message.sort(lambda x, y: cmp(x.bb, y.bb)) self.assertequal(message.repeated_nested_message[0].bb, 1) self.assertequal(message.repeated_nested_message[1].bb, 2) self.assertequal(message.repeated_nested_message[2].bb, 3) self.assertequal(message.repeated_nested_message[3].bb, 4) self.assertequal(message.repeated_nested_message[4].bb, 5) self.assertequal(message.repeated_nested_message[5].bb, 6)
def testextremedoublevalues(self): message = unittest_pb2.testalltypes() # most positive exponent, no significand bits set. kmostposexponentnosigbits = math.pow(2, 1023) message.optional_double = kmostposexponentnosigbits message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == kmostposexponentnosigbits) # most positive exponent, one significand bit set. kmostposexponentonesigbit = 1.5 * math.pow(2, 1023) message.optional_double = kmostposexponentonesigbit message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == kmostposexponentonesigbit) # repeat last two cases with values of same magnitude, but negative. message.optional_double = -kmostposexponentnosigbits message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == -kmostposexponentnosigbits) message.optional_double = -kmostposexponentonesigbit message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == -kmostposexponentonesigbit) # most negative exponent, no significand bits set. kmostnegexponentnosigbits = math.pow(2, -1023) message.optional_double = kmostnegexponentnosigbits message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == kmostnegexponentnosigbits) # most negative exponent, one significand bit set. kmostnegexponentonesigbit = 1.5 * math.pow(2, -1023) message.optional_double = kmostnegexponentonesigbit message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == kmostnegexponentonesigbit) # repeat last two cases with values of the same magnitude, but negative. message.optional_double = -kmostnegexponentnosigbits message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == -kmostnegexponentnosigbits) message.optional_double = -kmostnegexponentonesigbit message.parsefromstring(message.serializetostring()) self.asserttrue(message.optional_double == -kmostnegexponentonesigbit)
def testsortingrepeatedscalarfieldscustomcomparator(self): """check some different types with custom comparator.""" message = unittest_pb2.testalltypes() message.repeated_int32.append(-3) message.repeated_int32.append(-2) message.repeated_int32.append(-1) message.repeated_int32.sort(lambda x, y: cmp(abs(x), abs(y))) self.assertequal(message.repeated_int32[0], -1) self.assertequal(message.repeated_int32[1], -2) self.assertequal(message.repeated_int32[2], -3) message.repeated_string.append("aaa") message.repeated_string.append("bb") message.repeated_string.append("c") message.repeated_string.sort(lambda x, y: cmp(len(x), len(y))) self.assertequal(message.repeated_string[0], "c") self.assertequal(message.repeated_string[1], "bb") self.assertequal(message.repeated_string[2], "aaa")
def testmergestringfieldunescape(self): message = unittest_pb2.testalltypes() text = r'''repeated_string: "\xf\x62" repeated_string: "\\xf\\x62" repeated_string: "\\\xf\\\x62" repeated_string: "\\\\xf\\\\x62" repeated_string: "\\\\\xf\\\\\x62" repeated_string: "\x5cx20"''' text_format.merge(text, message) slash = '\\' self.assertequal('\x0fb', message.repeated_string[0]) self.assertequal(slash + 'xf' + slash + 'x62', message.repeated_string[1]) self.assertequal(slash + '\x0f' + slash + 'b', message.repeated_string[2]) self.assertequal(slash + slash + 'xf' + slash + slash + 'x62', message.repeated_string[3]) self.assertequal(slash + slash + '\x0f' + slash + slash + 'b', message.repeated_string[4]) self.assertequal(slash + 'x20', message.repeated_string[5])
def testprintexotic(self): message = unittest_pb2.testalltypes() message.repeated_int64.append(-9223372036854775808) message.repeated_uint64.append(18446744073709551615) message.repeated_double.append(123.456) message.repeated_double.append(1.23e22) message.repeated_double.append(1.23e-18) message.repeated_string.append('\000\001\a\b\f\n\r\t\v\\\'"') message.repeated_string.append(u'\u00fc\ua71f') self.comparetogoldentext( self.removeredundantzeros(text_format.messagetostring(message)), 'repeated_int64: -9223372036854775808\n' 'repeated_uint64: 18446744073709551615\n' 'repeated_double: 123.456\n' 'repeated_double: 1.23e+22\n' 'repeated_double: 1.23e-18\n' 'repeated_string: ' '"\\000\\001\\007\\010\\014\\n\\r\\t\\013\\\\\\\'\\""\n' 'repeated_string: "\\303\\274\\352\\234\\237"\n')