/* * Copyright (c) 2009-2021, Google LLC * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of Google LLC nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* Test of generated code, with a special focus on features that are not used in * descriptor.proto or conformance.proto (since these get some testing from * upb/def.c and tests/conformance_upb.c, respectively). */ #include "gtest/gtest.h" #include "google/protobuf/test_messages_proto2.upb.h" #include "google/protobuf/test_messages_proto3.upb.h" #include "upb/test.upb.h" #include "upb/upb.hpp" #if !defined(MIN) #define MIN(x, y) ((x) < (y) ? (x) : (y)) #endif const char test_str[] = "abcdefg"; const char test_str2[] = "12345678910"; const char test_str3[] = "rstlnezxcvbnm"; const char test_str4[] = "just another test string"; const upb_StringView test_str_view = {test_str, sizeof(test_str) - 1}; const upb_StringView test_str_view2 = {test_str2, sizeof(test_str2) - 1}; const upb_StringView test_str_view3 = {test_str3, sizeof(test_str3) - 1}; const upb_StringView test_str_view4 = {test_str4, sizeof(test_str4) - 1}; const int32_t test_int32 = 10; const int32_t test_int32_2 = -20; const int32_t test_int32_3 = 30; const int32_t test_int32_4 = -40; TEST(GeneratedCode, ScalarsProto3) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(arena); protobuf_test_messages_proto3_TestAllTypesProto3* msg2; upb_StringView serialized; upb_StringView val; // Test serialization. protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_int32(msg, 10); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_int64(msg, 20); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_uint32(msg, 30); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_uint64(msg, 40); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_float(msg, 50.5); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_double(msg, 60.6); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_bool(msg, 1); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_string( msg, test_str_view); serialized.data = protobuf_test_messages_proto3_TestAllTypesProto3_serialize( msg, arena, &serialized.size); msg2 = protobuf_test_messages_proto3_TestAllTypesProto3_parse( serialized.data, serialized.size, arena); EXPECT_EQ(10, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32( msg2)); EXPECT_EQ(20, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64( msg2)); EXPECT_EQ( 30, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint32(msg2)); EXPECT_EQ( 40, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg2)); EXPECT_EQ( 50.5, protobuf_test_messages_proto3_TestAllTypesProto3_optional_float(msg2)); EXPECT_EQ( 60.6, protobuf_test_messages_proto3_TestAllTypesProto3_optional_double(msg2)); EXPECT_EQ( true, protobuf_test_messages_proto3_TestAllTypesProto3_optional_bool(msg2)); val = protobuf_test_messages_proto3_TestAllTypesProto3_optional_string(msg2); EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view)); // Test clear. protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_int32(msg); EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_int64(msg); EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int64(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_uint32(msg); EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint32(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_uint64(msg); EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_uint64(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_float(msg); EXPECT_EQ( 0.0f, protobuf_test_messages_proto3_TestAllTypesProto3_optional_float(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_double(msg); EXPECT_EQ( 0.0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_double(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_bool(msg); EXPECT_EQ( false, protobuf_test_messages_proto3_TestAllTypesProto3_optional_bool(msg)); protobuf_test_messages_proto3_TestAllTypesProto3_clear_optional_string(msg); EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_optional_string(msg) .size); upb_Arena_Free(arena); } TEST(GeneratedCode, ScalarsProto2) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto2_TestAllTypesProto2* msg = protobuf_test_messages_proto2_TestAllTypesProto2_new(arena); protobuf_test_messages_proto2_TestAllTypesProto2* msg2; upb_StringView serialized; // Test hazzer and serialization. EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_int32(msg, 10); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_int64(msg, 20); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_uint32(msg, 30); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_uint64(msg, 40); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint32( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sint32(msg, 50); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint32( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint64( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sint64(msg, 60); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sint64( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed32( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_fixed32(msg, 70); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed32( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed64( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_fixed64(msg, 80); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_fixed64( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed32( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sfixed32(msg, 90); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed32( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed64( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_sfixed64(msg, 100); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_sfixed64( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_float(msg, 50.5); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_double(msg, 60.6); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double( msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_bool(msg, 1); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg)); serialized.data = protobuf_test_messages_proto2_TestAllTypesProto2_serialize( msg, arena, &serialized.size); msg2 = protobuf_test_messages_proto2_TestAllTypesProto2_parse( serialized.data, serialized.size, arena); EXPECT_EQ(10, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32( msg2)); EXPECT_EQ(20, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int64( msg2)); EXPECT_EQ( 30, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg2)); EXPECT_EQ( 40, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint64(msg2)); EXPECT_EQ( 50, protobuf_test_messages_proto2_TestAllTypesProto2_optional_sint32(msg2)); EXPECT_EQ( 60, protobuf_test_messages_proto2_TestAllTypesProto2_optional_sint64(msg2)); EXPECT_EQ( 70, protobuf_test_messages_proto2_TestAllTypesProto2_optional_fixed32(msg2)); EXPECT_EQ( 80, protobuf_test_messages_proto2_TestAllTypesProto2_optional_fixed64(msg2)); EXPECT_EQ( 90, protobuf_test_messages_proto2_TestAllTypesProto2_optional_sfixed32(msg2)); EXPECT_EQ( 100, protobuf_test_messages_proto2_TestAllTypesProto2_optional_sfixed64(msg2)); EXPECT_EQ( 50.5, protobuf_test_messages_proto2_TestAllTypesProto2_optional_float(msg2)); EXPECT_EQ( 60.6, protobuf_test_messages_proto2_TestAllTypesProto2_optional_double(msg2)); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg2)); // Test clear. protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int32(msg); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int32(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int32(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_int64(msg); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_int64(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_int64(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint32(msg); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint32(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint32( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_uint64(msg); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_uint64(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_uint64( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_float(msg); EXPECT_EQ( 0.0f, protobuf_test_messages_proto2_TestAllTypesProto2_optional_float(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_float(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_double(msg); EXPECT_EQ( 0.0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_double(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_double( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_bool(msg); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_optional_bool(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bool(msg)); upb_Arena_Free(arena); } TEST(GeneratedCode, Bytes) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto2_TestAllTypesProto2* msg = protobuf_test_messages_proto2_TestAllTypesProto2_new(arena); protobuf_test_messages_proto2_TestAllTypesProto2* msg2; upb_StringView serialized; const char data[] = "ABCDEF"; upb_StringView bytes = upb_StringView_FromString(data); upb_StringView val; EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_bytes(msg, bytes); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg)); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_set_optional_string( msg, test_str_view); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string( msg)); serialized.data = protobuf_test_messages_proto2_TestAllTypesProto2_serialize( msg, arena, &serialized.size); msg2 = protobuf_test_messages_proto2_TestAllTypesProto2_parse( serialized.data, serialized.size, arena); EXPECT_EQ(bytes.size, protobuf_test_messages_proto2_TestAllTypesProto2_optional_bytes(msg) .size); EXPECT_EQ( 0, memcmp(bytes.data, protobuf_test_messages_proto2_TestAllTypesProto2_optional_bytes( msg) .data, bytes.size)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_bytes(msg); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_bytes(msg)); val = protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg2); EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view)); protobuf_test_messages_proto2_TestAllTypesProto2_clear_optional_string(msg); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_optional_string(msg) .size); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_has_optional_string( msg)); upb_Arena_Free(arena); } TEST(GeneratedCode, Extension) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrect* msg = protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrect_new( arena); protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrect* msg2; upb_StringView serialized; EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_has_message_set_extension( msg)); protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2* ext = protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_new( arena); EXPECT_EQ( 0, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_i( ext)); protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_set_i( ext, 5); EXPECT_EQ( 5, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_i( ext)); // Test setter/hazzer. protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_set_message_set_extension( msg, ext, arena); EXPECT_EQ( true, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_has_message_set_extension( msg)); // Test serialize. serialized.data = protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrect_serialize( msg, arena, &serialized.size); msg2 = protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrect_parse( serialized.data, serialized.size, arena); const protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2* ext2 = protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_message_set_extension( msg); EXPECT_EQ( 5, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_i( ext2)); // Test Clear. protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_clear_message_set_extension( msg); EXPECT_EQ( false, protobuf_test_messages_proto2_TestAllTypesProto2_MessageSetCorrectExtension2_has_message_set_extension( msg)); upb_Arena_Free(arena); } TEST(GeneratedCode, RepeatedClear) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto2_TestAllTypesProto2* msg = protobuf_test_messages_proto2_TestAllTypesProto2_new(arena); size_t len = 0; protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len); EXPECT_EQ(0, len); protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 2, arena); protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 3, arena); protobuf_test_messages_proto2_TestAllTypesProto2_add_repeated_int32(msg, 4, arena); protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len); EXPECT_EQ(3, len); protobuf_test_messages_proto2_TestAllTypesProto2_clear_repeated_int32(msg); protobuf_test_messages_proto2_TestAllTypesProto2_repeated_int32(msg, &len); EXPECT_EQ(0, len); upb_Arena_Free(arena); } TEST(GeneratedCode, UTF8) { const char invalid_utf8[] = "\xff"; const upb_StringView invalid_utf8_view = upb_StringView_FromDataAndSize(invalid_utf8, 1); upb_Arena* arena = upb_Arena_New(); upb_StringView serialized; protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(arena); protobuf_test_messages_proto3_TestAllTypesProto3* msg2; protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_string( msg, invalid_utf8_view); serialized.data = protobuf_test_messages_proto3_TestAllTypesProto3_serialize( msg, arena, &serialized.size); msg2 = protobuf_test_messages_proto3_TestAllTypesProto3_parse( serialized.data, serialized.size, arena); EXPECT_EQ(nullptr, msg2); upb_Arena_Free(arena); } static void check_string_map_empty( protobuf_test_messages_proto3_TestAllTypesProto3* msg) { size_t iter = kUpb_Map_Begin; EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_size( msg)); EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next( msg, &iter)); } static void check_string_map_one_entry( protobuf_test_messages_proto3_TestAllTypesProto3* msg) { const protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry* const_ent; size_t iter; upb_StringView str; EXPECT_EQ( 1, protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_size( msg)); EXPECT_TRUE( protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_get( msg, test_str_view, &str)); EXPECT_TRUE(upb_StringView_IsEqual(str, test_str_view2)); EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_get( msg, test_str_view3, &str)); /* Test that iteration reveals a single k/v pair in the map. */ iter = kUpb_Map_Begin; const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next( msg, &iter); ASSERT_NE(nullptr, const_ent); EXPECT_TRUE(upb_StringView_IsEqual( test_str_view, protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_key( const_ent))); EXPECT_TRUE(upb_StringView_IsEqual( test_str_view2, protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_value( const_ent))); const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next( msg, &iter); EXPECT_EQ(nullptr, const_ent); } TEST(GeneratedCode, StringDoubleMap) { upb_Arena* arena = upb_Arena_New(); upb_StringView serialized; upb_test_MapTest* msg = upb_test_MapTest_new(arena); upb_test_MapTest* msg2; double val; upb_test_MapTest_map_string_double_set(msg, test_str_view, 1.5, arena); ASSERT_NE(nullptr, msg); EXPECT_TRUE(upb_test_MapTest_map_string_double_get(msg, test_str_view, &val)); EXPECT_EQ(1.5, val); val = 0; serialized.data = upb_test_MapTest_serialize(msg, arena, &serialized.size); EXPECT_NE(nullptr, serialized.data); msg2 = upb_test_MapTest_parse(serialized.data, serialized.size, arena); ASSERT_NE(nullptr, msg2); EXPECT_TRUE( upb_test_MapTest_map_string_double_get(msg2, test_str_view, &val)); EXPECT_EQ(1.5, val); upb_Arena_Free(arena); } TEST(GeneratedCode, StringMap) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(arena); const protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry* const_ent; size_t iter, count; check_string_map_empty(msg); /* Set map[test_str_view] = test_str_view2 */ protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set( msg, test_str_view, test_str_view2, arena); check_string_map_one_entry(msg); /* Deleting a non-existent key does nothing. */ EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_delete( msg, test_str_view3)); check_string_map_one_entry(msg); /* Deleting the key sets the map back to empty. */ EXPECT_TRUE( protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_delete( msg, test_str_view)); check_string_map_empty(msg); /* Set two keys this time: * map[test_str_view] = test_str_view2 * map[test_str_view3] = test_str_view4 */ protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set( msg, test_str_view, test_str_view2, arena); protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_set( msg, test_str_view3, test_str_view4, arena); /* Test iteration */ iter = kUpb_Map_Begin; count = 0; while ( (const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_next( msg, &iter)) != NULL) { upb_StringView key = protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_key( const_ent); upb_StringView val = protobuf_test_messages_proto3_TestAllTypesProto3_MapStringStringEntry_value( const_ent); count++; if (upb_StringView_IsEqual(key, test_str_view)) { EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view2)); } else { EXPECT_TRUE(upb_StringView_IsEqual(key, test_str_view3)); EXPECT_TRUE(upb_StringView_IsEqual(val, test_str_view4)); } } EXPECT_EQ(2, count); /* Clearing the map goes back to empty. */ protobuf_test_messages_proto3_TestAllTypesProto3_map_string_string_clear(msg); check_string_map_empty(msg); upb_Arena_Free(arena); } static void check_int32_map_empty( protobuf_test_messages_proto3_TestAllTypesProto3* msg) { size_t iter = kUpb_Map_Begin; EXPECT_EQ( 0, protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_size( msg)); EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next( msg, &iter)); } static void check_int32_map_one_entry( protobuf_test_messages_proto3_TestAllTypesProto3* msg) { const protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry* const_ent; size_t iter; int32_t val; EXPECT_EQ( 1, protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_size( msg)); EXPECT_TRUE( protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_get( msg, test_int32, &val)); EXPECT_EQ(val, test_int32_2); EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_get( msg, test_int32_3, &val)); /* Test that iteration reveals a single k/v pair in the map. */ iter = kUpb_Map_Begin; const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next( msg, &iter); ASSERT_NE(nullptr, const_ent); EXPECT_EQ( test_int32, protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_key( const_ent)); EXPECT_EQ( test_int32_2, protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_value( const_ent)); const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next( msg, &iter); EXPECT_EQ(nullptr, const_ent); } TEST(GeneratedCode, Int32Map) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(arena); const protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry* const_ent; size_t iter, count; check_int32_map_empty(msg); /* Set map[test_int32] = test_int32_2 */ protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set( msg, test_int32, test_int32_2, arena); check_int32_map_one_entry(msg); /* Deleting a non-existent key does nothing. */ EXPECT_FALSE( protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_delete( msg, test_int32_3)); check_int32_map_one_entry(msg); /* Deleting the key sets the map back to empty. */ EXPECT_TRUE( protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_delete( msg, test_int32)); check_int32_map_empty(msg); /* Set two keys this time: * map[test_int32] = test_int32_2 * map[test_int32_3] = test_int32_4 */ protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set( msg, test_int32, test_int32_2, arena); protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_set( msg, test_int32_3, test_int32_4, arena); /* Test iteration */ iter = kUpb_Map_Begin; count = 0; while ( (const_ent = protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_next( msg, &iter)) != NULL) { int32_t key = protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_key( const_ent); int32_t val = protobuf_test_messages_proto3_TestAllTypesProto3_MapInt32Int32Entry_value( const_ent); count++; if (key == test_int32) { EXPECT_EQ(val, test_int32_2); } else { EXPECT_EQ(key, test_int32_3); EXPECT_EQ(val, test_int32_4); } } EXPECT_EQ(2, count); /* Clearing the map goes back to empty. */ protobuf_test_messages_proto3_TestAllTypesProto3_map_int32_int32_clear(msg); check_int32_map_empty(msg); upb_Arena_Free(arena); } TEST(GeneratedCode, TestRepeated) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(arena); size_t size; const int* elems; protobuf_test_messages_proto3_TestAllTypesProto3_add_repeated_int32(msg, 5, arena); elems = protobuf_test_messages_proto3_TestAllTypesProto3_repeated_int32( msg, &size); EXPECT_EQ(1, size); EXPECT_EQ(5, elems[0]); upb_Arena_Free(arena); } TEST(GeneratedCode, Issue9440) { upb::Arena arena; upb_test_HelloRequest* msg = upb_test_HelloRequest_new(arena.ptr()); upb_test_HelloRequest_set_id(msg, 8); EXPECT_EQ(8, upb_test_HelloRequest_id(msg)); char str[] = "1"; upb_test_HelloRequest_set_version(msg, upb_StringView{str, strlen(str)}); EXPECT_EQ(8, upb_test_HelloRequest_id(msg)); } TEST(GeneratedCode, NullDecodeBuffer) { upb_Arena* arena = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_parse(NULL, 0, arena); size_t size; ASSERT_NE(nullptr, msg); protobuf_test_messages_proto3_TestAllTypesProto3_serialize(msg, arena, &size); EXPECT_EQ(0, size); upb_Arena_Free(arena); } TEST(GeneratedCode, StatusTruncation) { int i, j; upb_Status status; upb_Status status2; for (i = 0; i < _kUpb_Status_MaxMessage + 20; i++) { char* msg = static_cast(malloc(i + 1)); int end; char ch = (i % 96) + 33; /* Cycle through printable chars. */ for (j = 0; j < i; j++) { msg[j] = ch; } msg[i] = '\0'; upb_Status_SetErrorMessage(&status, msg); upb_Status_SetErrorFormat(&status2, "%s", msg); end = MIN(i, _kUpb_Status_MaxMessage - 1); EXPECT_EQ(end, strlen(status.msg)); EXPECT_EQ(end, strlen(status2.msg)); for (j = 0; j < end; j++) { EXPECT_EQ(ch, status.msg[j]); EXPECT_EQ(ch, status2.msg[j]); } free(msg); } } static void decrement_int(void* ptr) { int* iptr = static_cast(ptr); (*iptr)--; } TEST(GeneratedCode, ArenaFuse) { int i1 = 5; int i2 = 5; int i3 = 5; int i4 = 5; upb_Arena* arena1 = upb_Arena_New(); upb_Arena* arena2 = upb_Arena_New(); upb_Arena_AddCleanup(arena1, &i1, decrement_int); upb_Arena_AddCleanup(arena2, &i2, decrement_int); EXPECT_TRUE(upb_Arena_Fuse(arena1, arena2)); upb_Arena_AddCleanup(arena1, &i3, decrement_int); upb_Arena_AddCleanup(arena2, &i4, decrement_int); upb_Arena_Free(arena1); EXPECT_EQ(5, i1); EXPECT_EQ(5, i2); EXPECT_EQ(5, i3); EXPECT_EQ(5, i4); upb_Arena_Free(arena2); EXPECT_EQ(4, i1); EXPECT_EQ(4, i2); EXPECT_EQ(4, i3); EXPECT_EQ(4, i4); } /* Do nothing allocator for testing */ static void* test_allocfunc(upb_alloc* alloc, void* ptr, size_t oldsize, size_t size) { return upb_alloc_global.func(alloc, ptr, oldsize, size); } upb_alloc test_alloc = {&test_allocfunc}; TEST(GeneratedCode, FuseWithInitialBlock) { char buf1[1024]; char buf2[1024]; upb_Arena* arenas[] = {upb_Arena_Init(buf1, 1024, &upb_alloc_global), upb_Arena_Init(buf2, 1024, &upb_alloc_global), upb_Arena_Init(NULL, 0, &test_alloc), upb_Arena_Init(NULL, 0, &upb_alloc_global)}; int size = sizeof(arenas) / sizeof(arenas[0]); for (int i = 0; i < size; ++i) { for (int j = 0; j < size; ++j) { if (i == j) { EXPECT_TRUE(upb_Arena_Fuse(arenas[i], arenas[j])); } else { EXPECT_FALSE(upb_Arena_Fuse(arenas[i], arenas[j])); } } } for (int i = 0; i < size; ++i) upb_Arena_Free(arenas[i]); } TEST(GeneratedCode, ArenaDecode) { // Tests against a bug that previously existed when passing an arena to // upb_decode(). char large_string[1024] = {0}; upb_StringView large_string_view = {large_string, sizeof(large_string)}; upb_Arena* tmp = upb_Arena_New(); protobuf_test_messages_proto3_TestAllTypesProto3* msg = protobuf_test_messages_proto3_TestAllTypesProto3_new(tmp); protobuf_test_messages_proto3_TestAllTypesProto3_set_optional_bytes( msg, large_string_view); upb_StringView serialized; serialized.data = protobuf_test_messages_proto3_TestAllTypesProto3_serialize( msg, tmp, &serialized.size); upb_Arena* arena = upb_Arena_New(); // Parse the large payload, forcing an arena block to be allocated. This used // to corrupt the cleanup list, preventing subsequent upb_Arena_AddCleanup() // calls from working properly. protobuf_test_messages_proto3_TestAllTypesProto3_parse( serialized.data, serialized.size, arena); int i1 = 5; upb_Arena_AddCleanup(arena, &i1, decrement_int); EXPECT_EQ(5, i1); upb_Arena_Free(arena); EXPECT_EQ(4, i1); upb_Arena_Free(tmp); } TEST(GeneratedCode, ArenaUnaligned) { char buf1[1024]; // Force the pointer to be unaligned. char* unaligned_buf_ptr = (char*)((uintptr_t)buf1 | 7); upb_Arena* arena = upb_Arena_Init( unaligned_buf_ptr, &buf1[sizeof(buf1)] - unaligned_buf_ptr, NULL); char* mem = static_cast(upb_Arena_Malloc(arena, 5)); EXPECT_EQ(0, reinterpret_cast(mem) & 15); upb_Arena_Free(arena); // Try the same, but with a size so small that aligning up will overflow. arena = upb_Arena_Init(unaligned_buf_ptr, 5, &upb_alloc_global); mem = static_cast(upb_Arena_Malloc(arena, 5)); EXPECT_EQ(0, reinterpret_cast(mem) & 15); upb_Arena_Free(arena); }