1/* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15#include <limits> 16#include <memory> 17#include <vector> 18#include <gtest/gtest.h> 19 20#include "base_message.h" 21#include "example.pb.h" 22#include "example.pbencoder.h" 23 24namespace OHOS { 25namespace Developtools { 26namespace Profiler { 27using namespace testing::ext; 28 29constexpr uint32_t SIZE_BUFFER = 1024 * 1024; 30static uint8_t g_buf[SIZE_BUFFER] = {0}; 31static uint32_t g_writePos = 0; 32 33bool GetMemory(RandomWriteCtx* ctx, uint32_t size, uint8_t** memory, uint32_t* offset) 34{ 35 if (g_writePos + size > sizeof(g_buf)) { 36 return false; 37 } 38 39 *memory = &g_buf[g_writePos]; 40 *offset = g_writePos; 41 return true; 42} 43 44bool Seek(RandomWriteCtx* ctx, uint32_t offset) 45{ 46 if (offset >= sizeof(g_buf)) { 47 return false; 48 } 49 50 g_writePos = offset; 51 return true; 52} 53 54static RandomWriteCtx g_writeCtx = {GetMemory, Seek}; 55 56class BaseMessageUnittest : public ::testing::Test { 57public: 58 static void SetUpTestCase() {}; 59 static void TearDownTestCase() {}; 60 61 void SetUp() 62 { 63 g_writePos = 0; 64 } 65 void TearDown() {}; 66}; 67 68HWTEST_F(BaseMessageUnittest, Size, TestSize.Level1) 69{ 70 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 71 g_writeCtx.seek(&g_writeCtx, 0); 72 msgOpt.set_vint_int32(1); 73 msgOpt.set_vint_int64(1); 74 msgOpt.set_vint_uint32(1); 75 msgOpt.set_vint_uint64(1); 76 msgOpt.set_vint_sint32(1); 77 msgOpt.set_vint_sint64(1); 78 msgOpt.set_vint_bool(true); 79 msgOpt.set_vint_enum(ProtoEncoder::NUM::ONE); 80 ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size()); 81 82 const std::string str = "this is test."; 83 msgOpt.set_len_string(str); 84 msgOpt.set_len_bytes(str.data(), str.size()); 85 ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size()); 86 87 ProtoEncoder::SubMessage* msgSub = msgOpt.mutable_len_sub(); 88 ASSERT_TRUE(msgSub != nullptr); 89 msgSub->set_vint_int32(1); 90 msgSub->set_vint_int64(1); 91 msgSub->set_vint_uint32(1); 92 msgSub->set_vint_uint64(1); 93 // has not backfill the length of subMessage 94 ASSERT_GT(g_writePos, (uint32_t)msgOpt.Size()); 95 96 msgOpt.set_i64_fixed64(1); 97 msgOpt.set_i64_sfixed64(1); 98 msgOpt.set_i64_double(1); 99 ASSERT_EQ(g_writePos, (uint32_t)msgOpt.Size()); 100} 101 102HWTEST_F(BaseMessageUnittest, SetVarintInt32, TestSize.Level1) 103{ 104 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 105 ExampleMessage msgProtobuf; 106 107 g_writeCtx.seek(&g_writeCtx, 0); 108 msgOpt.set_vint_int32(0); 109 printf("set_vint_int32(0):\n"); 110 for (uint32_t i = 0; i < g_writePos; i++) { 111 printf("%02X ", g_buf[i]); 112 } 113 printf("\n"); 114 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 115 ASSERT_EQ(msgProtobuf.vint_int32(), 0); 116 117 // min 118 g_writeCtx.seek(&g_writeCtx, 0); 119 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 120 printf("set_vint_int32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min()); 121 for (uint32_t i = 0; i < g_writePos; i++) { 122 printf("%02X ", g_buf[i]); 123 } 124 printf("\n"); 125 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 126 ASSERT_EQ(msgProtobuf.vint_int32(), std::numeric_limits<int32_t>::min()); 127 128 // max 129 g_writeCtx.seek(&g_writeCtx, 0); 130 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::max()); 131 printf("set_vint_int32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max()); 132 for (uint32_t i = 0; i < g_writePos; i++) { 133 printf("%02X ", g_buf[i]); 134 } 135 printf("\n"); 136 137 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 138 ASSERT_EQ(msgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max()); 139} 140 141HWTEST_F(BaseMessageUnittest, SetVarintInt64, TestSize.Level1) 142{ 143 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 144 ExampleMessage msgProtobuf; 145 146 g_writeCtx.seek(&g_writeCtx, 0); 147 msgOpt.set_vint_int64(0); 148 printf("set_vint_int64(0):\n"); 149 for (uint32_t i = 0; i < g_writePos; i++) { 150 printf("%02X ", g_buf[i]); 151 } 152 printf("\n"); 153 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 154 ASSERT_EQ(msgProtobuf.vint_int64(), 0); 155 156 // min 157 g_writeCtx.seek(&g_writeCtx, 0); 158 msgOpt.set_vint_int64(std::numeric_limits<int64_t>::min()); 159 printf("set_vint_int64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max()); 160 for (uint32_t i = 0; i < g_writePos; i++) { 161 printf("%02X ", g_buf[i]); 162 } 163 printf("\n"); 164 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 165 ASSERT_EQ(msgProtobuf.vint_int64(), std::numeric_limits<int64_t>::min()); 166 167 // max 168 g_writeCtx.seek(&g_writeCtx, 0); 169 msgOpt.set_vint_int64(std::numeric_limits<int64_t>::max()); 170 printf("set_vint_int64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max()); 171 for (uint32_t i = 0; i < g_writePos; i++) { 172 printf("%02X ", g_buf[i]); 173 } 174 printf("\n"); 175 176 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 177 ASSERT_EQ(msgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max()); 178} 179 180HWTEST_F(BaseMessageUnittest, SetVarintUint32, TestSize.Level1) 181{ 182 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 183 ExampleMessage msgProtobuf; 184 185 g_writeCtx.seek(&g_writeCtx, 0); 186 msgOpt.set_vint_uint32(0); 187 printf("set_vint_uint32(0):\n"); 188 for (uint32_t i = 0; i < g_writePos; i++) { 189 printf("%02X ", g_buf[i]); 190 } 191 printf("\n"); 192 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 193 ASSERT_EQ(msgProtobuf.vint_uint32(), (uint32_t)0); 194 195 // min 196 g_writeCtx.seek(&g_writeCtx, 0); 197 msgOpt.set_vint_uint32(std::numeric_limits<uint32_t>::min()); 198 printf("set_vint_uint32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::min()); 199 for (uint32_t i = 0; i < g_writePos; i++) { 200 printf("%02X ", g_buf[i]); 201 } 202 printf("\n"); 203 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 204 ASSERT_EQ(msgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::min()); 205 206 // max 207 g_writeCtx.seek(&g_writeCtx, 0); 208 msgOpt.set_vint_uint32(std::numeric_limits<uint32_t>::max()); 209 printf("set_vint_uint32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::max()); 210 for (uint32_t i = 0; i < g_writePos; i++) { 211 printf("%02X ", g_buf[i]); 212 } 213 printf("\n"); 214 215 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 216 ASSERT_EQ(msgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max()); 217} 218 219HWTEST_F(BaseMessageUnittest, SetVarintUint64, TestSize.Level1) 220{ 221 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 222 ExampleMessage msgProtobuf; 223 224 g_writeCtx.seek(&g_writeCtx, 0); 225 msgOpt.set_vint_uint64(0); 226 printf("set_vint_uint64(0):\n"); 227 for (uint32_t i = 0; i < g_writePos; i++) { 228 printf("%02X ", g_buf[i]); 229 } 230 printf("\n"); 231 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 232 ASSERT_EQ(msgProtobuf.vint_uint64(), (uint64_t)0); 233 234 // min 235 g_writeCtx.seek(&g_writeCtx, 0); 236 msgOpt.set_vint_uint64(std::numeric_limits<uint64_t>::min()); 237 printf("set_vint_uint64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::min()); 238 for (uint32_t i = 0; i < g_writePos; i++) { 239 printf("%02X ", g_buf[i]); 240 } 241 printf("\n"); 242 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 243 ASSERT_EQ(msgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::min()); 244 245 // max 246 g_writeCtx.seek(&g_writeCtx, 0); 247 msgOpt.set_vint_uint64(std::numeric_limits<uint64_t>::max()); 248 printf("set_vint_uint64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::max()); 249 for (uint32_t i = 0; i < g_writePos; i++) { 250 printf("%02X ", g_buf[i]); 251 } 252 printf("\n"); 253 254 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 255 ASSERT_EQ(msgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max()); 256} 257 258HWTEST_F(BaseMessageUnittest, SetVarintSint32, TestSize.Level1) 259{ 260 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 261 ExampleMessage msgProtobuf; 262 263 g_writeCtx.seek(&g_writeCtx, 0); 264 msgOpt.set_vint_sint32(0); 265 printf("set_vint_sint32(0):\n"); 266 for (uint32_t i = 0; i < g_writePos; i++) { 267 printf("%02X ", g_buf[i]); 268 } 269 printf("\n"); 270 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 271 ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)0); 272 273 // min 274 g_writeCtx.seek(&g_writeCtx, 0); 275 msgOpt.set_vint_sint32(std::numeric_limits<int32_t>::min()); 276 printf("set_vint_sint32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min()); 277 for (uint32_t i = 0; i < g_writePos; i++) { 278 printf("%02X ", g_buf[i]); 279 } 280 printf("\n"); 281 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 282 ASSERT_EQ(msgProtobuf.vint_sint32(), std::numeric_limits<int32_t>::min()); 283 284 // max 285 g_writeCtx.seek(&g_writeCtx, 0); 286 msgOpt.set_vint_sint32(std::numeric_limits<int32_t>::max()); 287 printf("set_vint_sint32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max()); 288 for (uint32_t i = 0; i < g_writePos; i++) { 289 printf("%02X ", g_buf[i]); 290 } 291 printf("\n"); 292 293 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 294 ASSERT_EQ(msgProtobuf.vint_sint32(), std::numeric_limits<int32_t>::max()); 295} 296 297HWTEST_F(BaseMessageUnittest, SetVarintSint64, TestSize.Level1) 298{ 299 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 300 ExampleMessage msgProtobuf; 301 302 g_writeCtx.seek(&g_writeCtx, 0); 303 msgOpt.set_vint_sint64(0); 304 printf("set_vint_sint64(0):\n"); 305 for (uint32_t i = 0; i < g_writePos; i++) { 306 printf("%02X ", g_buf[i]); 307 } 308 printf("\n"); 309 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 310 ASSERT_EQ(msgProtobuf.vint_sint64(), (int64_t)0); 311 312 // min 313 g_writeCtx.seek(&g_writeCtx, 0); 314 msgOpt.set_vint_sint64(std::numeric_limits<int64_t>::min()); 315 printf("set_vint_sint64(%" PRId64 "):\n", std::numeric_limits<int64_t>::min()); 316 for (uint32_t i = 0; i < g_writePos; i++) { 317 printf("%02X ", g_buf[i]); 318 } 319 printf("\n"); 320 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 321 ASSERT_EQ(msgProtobuf.vint_sint64(), std::numeric_limits<int64_t>::min()); 322 323 // max 324 g_writeCtx.seek(&g_writeCtx, 0); 325 msgOpt.set_vint_sint64(std::numeric_limits<int64_t>::max()); 326 printf("set_vint_sint64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max()); 327 for (uint32_t i = 0; i < g_writePos; i++) { 328 printf("%02X ", g_buf[i]); 329 } 330 printf("\n"); 331 332 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 333 ASSERT_EQ(msgProtobuf.vint_sint64(), std::numeric_limits<int64_t>::max()); 334} 335 336HWTEST_F(BaseMessageUnittest, SetVarintBool, TestSize.Level1) 337{ 338 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 339 ExampleMessage msgProtobuf; 340 341 // min 342 g_writeCtx.seek(&g_writeCtx, 0); 343 msgOpt.set_vint_bool(std::numeric_limits<bool>::min()); 344 printf("set_vint_bool(%d):\n", std::numeric_limits<bool>::min()); 345 for (uint32_t i = 0; i < g_writePos; i++) { 346 printf("%02X ", g_buf[i]); 347 } 348 printf("\n"); 349 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 350 ASSERT_EQ(msgProtobuf.vint_bool(), std::numeric_limits<bool>::min()); 351 352 // max 353 g_writeCtx.seek(&g_writeCtx, 0); 354 msgOpt.set_vint_bool(std::numeric_limits<int64_t>::max()); 355 printf("set_vint_bool(%d):\n", std::numeric_limits<bool>::max()); 356 for (uint32_t i = 0; i < g_writePos; i++) { 357 printf("%02X ", g_buf[i]); 358 } 359 printf("\n"); 360 361 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 362 ASSERT_EQ(msgProtobuf.vint_bool(), std::numeric_limits<bool>::max()); 363} 364 365HWTEST_F(BaseMessageUnittest, SetVarintEnum, TestSize.Level1) 366{ 367 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 368 ExampleMessage msgProtobuf; 369 370 // min 371 g_writeCtx.seek(&g_writeCtx, 0); 372 msgOpt.set_vint_enum(ProtoEncoder::NUM::ZERO); 373 printf("set_vint_enum(%d):\n", static_cast<int>(ProtoEncoder::NUM::ZERO)); 374 for (uint32_t i = 0; i < g_writePos; i++) { 375 printf("%02X ", g_buf[i]); 376 } 377 printf("\n"); 378 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 379 ASSERT_EQ(msgProtobuf.vint_enum(), static_cast<int>(ProtoEncoder::NUM::ZERO)); 380 381 // max 382 g_writeCtx.seek(&g_writeCtx, 0); 383 msgOpt.set_vint_enum(ProtoEncoder::NUM::FOUR); 384 printf("set_vint_enum(%d):\n", static_cast<int>(ProtoEncoder::NUM::FOUR)); 385 for (uint32_t i = 0; i < g_writePos; i++) { 386 printf("%02X ", g_buf[i]); 387 } 388 printf("\n"); 389 390 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 391 ASSERT_EQ(msgProtobuf.vint_enum(), static_cast<int>(ProtoEncoder::NUM::FOUR)); 392} 393 394HWTEST_F(BaseMessageUnittest, SetFixed64, TestSize.Level1) 395{ 396 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 397 ExampleMessage msgProtobuf; 398 399 g_writeCtx.seek(&g_writeCtx, 0); 400 msgOpt.set_i64_fixed64(0); 401 printf("set_i64_fixed64(0):\n"); 402 for (uint32_t i = 0; i < g_writePos; i++) { 403 printf("%02X ", g_buf[i]); 404 } 405 printf("\n"); 406 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 407 ASSERT_EQ(msgProtobuf.i64_fixed64(), (uint64_t)0); 408 409 // min 410 g_writeCtx.seek(&g_writeCtx, 0); 411 msgOpt.set_i64_fixed64(std::numeric_limits<uint64_t>::min()); 412 printf("set_i64_fixed64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::min()); 413 for (uint32_t i = 0; i < g_writePos; i++) { 414 printf("%02X ", g_buf[i]); 415 } 416 printf("\n"); 417 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 418 ASSERT_EQ(msgProtobuf.i64_fixed64(), std::numeric_limits<uint64_t>::min()); 419 420 // max 421 g_writeCtx.seek(&g_writeCtx, 0); 422 msgOpt.set_i64_fixed64(std::numeric_limits<uint64_t>::max()); 423 printf("set_i64_fixed64(%" PRIu64 "):\n", std::numeric_limits<uint64_t>::max()); 424 for (uint32_t i = 0; i < g_writePos; i++) { 425 printf("%02X ", g_buf[i]); 426 } 427 printf("\n"); 428 429 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 430 ASSERT_EQ(msgProtobuf.i64_fixed64(), std::numeric_limits<uint64_t>::max()); 431} 432 433HWTEST_F(BaseMessageUnittest, SetSfixed64, TestSize.Level1) 434{ 435 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 436 ExampleMessage msgProtobuf; 437 438 g_writeCtx.seek(&g_writeCtx, 0); 439 msgOpt.set_i64_sfixed64(0); 440 printf("set_i64_sfixed64(0):\n"); 441 for (uint32_t i = 0; i < g_writePos; i++) { 442 printf("%02X ", g_buf[i]); 443 } 444 printf("\n"); 445 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 446 ASSERT_EQ(msgProtobuf.i64_sfixed64(), (int64_t)0); 447 448 // min 449 g_writeCtx.seek(&g_writeCtx, 0); 450 msgOpt.set_i64_sfixed64(std::numeric_limits<int64_t>::min()); 451 printf("set_i64_sfixed64(%" PRId64 "):\n", std::numeric_limits<int64_t>::min()); 452 for (uint32_t i = 0; i < g_writePos; i++) { 453 printf("%02X ", g_buf[i]); 454 } 455 printf("\n"); 456 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 457 ASSERT_EQ(msgProtobuf.i64_sfixed64(), std::numeric_limits<int64_t>::min()); 458 459 // max 460 g_writeCtx.seek(&g_writeCtx, 0); 461 msgOpt.set_i64_sfixed64(std::numeric_limits<int64_t>::max()); 462 printf("set_i64_sfixed64(%" PRId64 "):\n", std::numeric_limits<int64_t>::max()); 463 for (uint32_t i = 0; i < g_writePos; i++) { 464 printf("%02X ", g_buf[i]); 465 } 466 printf("\n"); 467 468 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 469 ASSERT_EQ(msgProtobuf.i64_sfixed64(), std::numeric_limits<int64_t>::max()); 470} 471 472HWTEST_F(BaseMessageUnittest, SetDouble, TestSize.Level1) 473{ 474 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 475 ExampleMessage msgProtobuf; 476 477 g_writeCtx.seek(&g_writeCtx, 0); 478 msgOpt.set_i64_double(0); 479 printf("set_i64_double(0):\n"); 480 for (uint32_t i = 0; i < g_writePos; i++) { 481 printf("%02X ", g_buf[i]); 482 } 483 printf("\n"); 484 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 485 ASSERT_EQ(msgProtobuf.i64_double(), (double)0); 486 487 // min 488 g_writeCtx.seek(&g_writeCtx, 0); 489 msgOpt.set_i64_double(std::numeric_limits<double>::min()); 490 printf("set_i64_double(%e):\n", std::numeric_limits<double>::min()); 491 for (uint32_t i = 0; i < g_writePos; i++) { 492 printf("%02X ", g_buf[i]); 493 } 494 printf("\n"); 495 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 496 ASSERT_EQ(msgProtobuf.i64_double(), std::numeric_limits<double>::min()); 497 498 // max 499 g_writeCtx.seek(&g_writeCtx, 0); 500 msgOpt.set_i64_double(std::numeric_limits<double>::max()); 501 printf("set_i64_double(%e):\n", std::numeric_limits<double>::max()); 502 for (uint32_t i = 0; i < g_writePos; i++) { 503 printf("%02X ", g_buf[i]); 504 } 505 printf("\n"); 506 507 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 508 ASSERT_EQ(msgProtobuf.i64_double(), std::numeric_limits<double>::max()); 509} 510 511HWTEST_F(BaseMessageUnittest, SetFixed32, TestSize.Level1) 512{ 513 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 514 ExampleMessage msgProtobuf; 515 516 g_writeCtx.seek(&g_writeCtx, 0); 517 msgOpt.set_i32_fixed32(0); 518 printf("set_i32_fixed32(0):\n"); 519 for (uint32_t i = 0; i < g_writePos; i++) { 520 printf("%02X ", g_buf[i]); 521 } 522 printf("\n"); 523 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 524 ASSERT_EQ(msgProtobuf.i32_fixed32(), (uint32_t)0); 525 526 // min 527 g_writeCtx.seek(&g_writeCtx, 0); 528 msgOpt.set_i32_fixed32(std::numeric_limits<uint32_t>::min()); 529 printf("set_i32_fixed32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::min()); 530 for (uint32_t i = 0; i < g_writePos; i++) { 531 printf("%02X ", g_buf[i]); 532 } 533 printf("\n"); 534 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 535 ASSERT_EQ(msgProtobuf.i32_fixed32(), std::numeric_limits<uint32_t>::min()); 536 537 // max 538 g_writeCtx.seek(&g_writeCtx, 0); 539 msgOpt.set_i32_fixed32(std::numeric_limits<uint32_t>::max()); 540 printf("set_i32_fixed32(%" PRIu32 "):\n", std::numeric_limits<uint32_t>::max()); 541 for (uint32_t i = 0; i < g_writePos; i++) { 542 printf("%02X ", g_buf[i]); 543 } 544 printf("\n"); 545 546 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 547 ASSERT_EQ(msgProtobuf.i32_fixed32(), std::numeric_limits<uint32_t>::max()); 548} 549 550HWTEST_F(BaseMessageUnittest, SetSfixed32, TestSize.Level1) 551{ 552 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 553 ExampleMessage msgProtobuf; 554 555 g_writeCtx.seek(&g_writeCtx, 0); 556 msgOpt.set_i32_sfixed32(0); 557 printf("set_i32_sfixed32(0):\n"); 558 for (uint32_t i = 0; i < g_writePos; i++) { 559 printf("%02X ", g_buf[i]); 560 } 561 printf("\n"); 562 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 563 ASSERT_EQ(msgProtobuf.i32_sfixed32(), (int32_t)0); 564 565 // min 566 g_writeCtx.seek(&g_writeCtx, 0); 567 msgOpt.set_i32_sfixed32(std::numeric_limits<int32_t>::min()); 568 printf("set_i32_sfixed32(%" PRId32 "):\n", std::numeric_limits<int32_t>::min()); 569 for (uint32_t i = 0; i < g_writePos; i++) { 570 printf("%02X ", g_buf[i]); 571 } 572 printf("\n"); 573 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 574 ASSERT_EQ(msgProtobuf.i32_sfixed32(), std::numeric_limits<int32_t>::min()); 575 576 // max 577 g_writeCtx.seek(&g_writeCtx, 0); 578 msgOpt.set_i32_sfixed32(std::numeric_limits<int32_t>::max()); 579 printf("set_i32_sfixed32(%" PRId32 "):\n", std::numeric_limits<int32_t>::max()); 580 for (uint32_t i = 0; i < g_writePos; i++) { 581 printf("%02X ", g_buf[i]); 582 } 583 printf("\n"); 584 585 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 586 ASSERT_EQ(msgProtobuf.i32_sfixed32(), std::numeric_limits<int32_t>::max()); 587} 588 589HWTEST_F(BaseMessageUnittest, SetFloat, TestSize.Level1) 590{ 591 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 592 ExampleMessage msgProtobuf; 593 594 g_writeCtx.seek(&g_writeCtx, 0); 595 msgOpt.set_i32_float(0); 596 printf("set_i32_float(0):\n"); 597 for (uint32_t i = 0; i < g_writePos; i++) { 598 printf("%02X ", g_buf[i]); 599 } 600 printf("\n"); 601 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 602 ASSERT_EQ(msgProtobuf.i32_float(), (float)0); 603 604 // min 605 g_writeCtx.seek(&g_writeCtx, 0); 606 msgOpt.set_i32_float(std::numeric_limits<float>::min()); 607 printf("set_i32_float(%e):\n", std::numeric_limits<float>::min()); 608 for (uint32_t i = 0; i < g_writePos; i++) { 609 printf("%02X ", g_buf[i]); 610 } 611 printf("\n"); 612 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 613 ASSERT_EQ(msgProtobuf.i32_float(), std::numeric_limits<float>::min()); 614 615 // max 616 g_writeCtx.seek(&g_writeCtx, 0); 617 msgOpt.set_i32_float(std::numeric_limits<float>::max()); 618 printf("set_i32_float(%e):\n", std::numeric_limits<float>::max()); 619 for (uint32_t i = 0; i < g_writePos; i++) { 620 printf("%02X ", g_buf[i]); 621 } 622 printf("\n"); 623 624 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 625 ASSERT_EQ(msgProtobuf.i32_float(), std::numeric_limits<float>::max()); 626} 627 628HWTEST_F(BaseMessageUnittest, SetString, TestSize.Level1) 629{ 630 const std::string emptyStr = ""; 631 const std::string str = "this is test."; 632 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 633 ExampleMessage msgProtobuf; 634 635 g_writeCtx.seek(&g_writeCtx, 0); 636 msgOpt.set_len_string(emptyStr); 637 printf("set_len_string(empty string):\n"); 638 for (uint32_t i = 0; i < g_writePos; i++) { 639 printf("%02X ", g_buf[i]); 640 } 641 printf("\n"); 642 // data of g_buf should is "AA 01 00" 643 const int32_t emptyStrFieldLen = 3; 644 ASSERT_EQ(msgOpt.Size(), emptyStrFieldLen); 645 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 646 ASSERT_EQ(msgProtobuf.len_string(), emptyStr); 647 648 g_writeCtx.seek(&g_writeCtx, 0); 649 msgOpt.set_len_string(str); 650 printf("set_len_string(string: %s):\n", str.c_str()); 651 for (uint32_t i = 0; i < g_writePos; i++) { 652 printf("%02X ", g_buf[i]); 653 } 654 printf("\n"); 655 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 656 ASSERT_EQ(msgProtobuf.len_string(), str); 657 658 g_writeCtx.seek(&g_writeCtx, 0); 659 msgOpt.set_len_string(str.c_str()); 660 printf("set_len_string(char*: %s):\n", str.c_str()); 661 for (uint32_t i = 0; i < g_writePos; i++) { 662 printf("%02X ", g_buf[i]); 663 } 664 printf("\n"); 665 666 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 667 ASSERT_EQ(msgProtobuf.len_string(), str); 668} 669 670HWTEST_F(BaseMessageUnittest, SetSubMessage, TestSize.Level1) 671{ 672 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 673 ExampleMessage msgProtobuf; 674 675 // empty 676 g_writeCtx.seek(&g_writeCtx, 0); 677 ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub(); 678 ASSERT_TRUE(subMsgOpt != nullptr); 679 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 680 printf("mutable_len_sub: nothing:\n"); 681 for (uint32_t i = 0; i < g_writePos; i++) { 682 printf("%02X ", g_buf[i]); 683 } 684 printf("\n"); 685 686 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 687 ASSERT_TRUE(msgProtobuf.has_len_sub()); 688 689 // min 690 g_writeCtx.seek(&g_writeCtx, 0); 691 subMsgOpt = msgOpt.mutable_len_sub(); 692 ASSERT_TRUE(subMsgOpt != nullptr); 693 subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::min()); 694 subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::min()); 695 subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::min()); 696 subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::min()); 697 698 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 699 printf("mutable_len_sub: min:\n"); 700 for (uint32_t i = 0; i < g_writePos; i++) { 701 printf("%02X ", g_buf[i]); 702 } 703 printf("\n"); 704 705 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 706 ASSERT_TRUE(msgProtobuf.has_len_sub()); 707 SubMessage subMsgProtobuf = msgProtobuf.len_sub(); 708 ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::min()); 709 ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::min()); 710 ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::min()); 711 ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::min()); 712 713 // max 714 g_writeCtx.seek(&g_writeCtx, 0); 715 subMsgOpt = msgOpt.mutable_len_sub(); 716 ASSERT_TRUE(subMsgOpt != nullptr); 717 subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::max()); 718 subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::max()); 719 subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::max()); 720 subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::max()); 721 722 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 723 printf("mutable_len_sub: max:\n"); 724 for (uint32_t i = 0; i < g_writePos; i++) { 725 printf("%02X ", g_buf[i]); 726 } 727 printf("\n"); 728 729 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 730 ASSERT_TRUE(msgProtobuf.has_len_sub()); 731 subMsgProtobuf = msgProtobuf.len_sub(); 732 ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max()); 733 ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max()); 734 ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max()); 735 ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max()); 736} 737 738HWTEST_F(BaseMessageUnittest, SetOneOf, TestSize.Level1) 739{ 740 const std::string str = "this is test."; 741 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 742 ExampleMessage msgProtobuf; 743 744 // oneof_fixed64 745 g_writeCtx.seek(&g_writeCtx, 0); 746 msgOpt.set_oneof_fixed64(std::numeric_limits<uint64_t>::max()); 747 printf("set_oneof_fixed64(%" PRIu64"):\n", std::numeric_limits<uint64_t>::max()); 748 for (uint32_t i = 0; i < g_writePos; i++) { 749 printf("%02X ", g_buf[i]); 750 } 751 printf("\n"); 752 753 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 754 ASSERT_EQ(msgProtobuf.oneof_fixed64(), std::numeric_limits<uint64_t>::max()); 755 756 // oneof_sub 757 ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_oneof_sub(); 758 ASSERT_TRUE(subMsgOpt != nullptr); 759 subMsgOpt->set_vint_int32(std::numeric_limits<int32_t>::max()); 760 subMsgOpt->set_vint_int64(std::numeric_limits<int64_t>::max()); 761 subMsgOpt->set_vint_uint32(std::numeric_limits<uint32_t>::max()); 762 subMsgOpt->set_vint_uint64(std::numeric_limits<uint64_t>::max()); 763 msgOpt.set_i32_fixed32(0); 764 printf("mutable_oneof_sub: max:\n"); 765 for (uint32_t i = 0; i < g_writePos; i++) { 766 printf("%02X ", g_buf[i]); 767 } 768 printf("\n"); 769 770 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 771 ASSERT_TRUE(msgProtobuf.has_oneof_sub()); 772 SubMessage subMsgProtobuf = msgProtobuf.oneof_sub(); 773 ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max()); 774 ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max()); 775 ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max()); 776 ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max()); 777 778 // oneof_string 779 msgOpt.set_oneof_string(str); 780 printf("set_oneof_string(%s):\n", str.c_str()); 781 for (uint32_t i = 0; i < g_writePos; i++) { 782 printf("%02X ", g_buf[i]); 783 } 784 printf("\n"); 785 786 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 787 ASSERT_EQ(msgProtobuf.oneof_string(), str); 788 789 // last one wins 790 ASSERT_NE(msgProtobuf.oneof_fixed64(), std::numeric_limits<uint64_t>::max()); 791 ASSERT_FALSE(msgProtobuf.has_oneof_sub()); 792} 793 794HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintSigned, TestSize.Level1) 795{ 796 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 797 ExampleMessage msgProtobuf; 798 const int32_t array[] = {0, 1, 799 std::numeric_limits<int32_t>::min(), 800 std::numeric_limits<int32_t>::max()}; 801 std::vector<int32_t> vec; 802 vec.emplace_back(0); 803 vec.emplace_back(1); 804 vec.emplace_back(std::numeric_limits<int32_t>::min()); 805 vec.emplace_back(std::numeric_limits<int32_t>::max()); 806 807 // vector 808 g_writeCtx.seek(&g_writeCtx, 0); 809 msgOpt.add_len_repeated_packed_signed_vint(vec); 810 printf("add_len_repeated_packed_signed_vint(vector):\n"); 811 for (uint32_t i = 0; i < g_writePos; i++) { 812 printf("%02X ", g_buf[i]); 813 } 814 printf("\n"); 815 816 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 817 int count = msgProtobuf.len_repeated_packed_signed_vint_size(); 818 ASSERT_EQ(count, static_cast<int>(vec.size())); 819 for (int i = 0; i < count; i++) { 820 ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vec[i]); 821 } 822 823 // array 824 msgOpt.add_len_repeated_packed_signed_vint(array, sizeof(array) / sizeof(array[0])); 825 printf("add_len_repeated_packed_signed_vint(array):\n"); 826 for (uint32_t i = 0; i < g_writePos; i++) { 827 printf("%02X ", g_buf[i]); 828 } 829 printf("\n"); 830 831 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 832 int countAll = msgProtobuf.len_repeated_packed_signed_vint_size(); 833 ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0]))); 834 for (int i = 0; i < count; i++) { 835 ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vec[i]); 836 } 837 for (int i = count; i < countAll; i++) { 838 ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), array[i - count]); 839 } 840} 841 842HWTEST_F(BaseMessageUnittest, SetRepeatedPackedVarintUnsigned, TestSize.Level1) 843{ 844 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 845 ExampleMessage msgProtobuf; 846 const uint32_t array[] = {0, 1, 847 std::numeric_limits<uint32_t>::min(), 848 std::numeric_limits<uint32_t>::max()}; 849 std::vector<uint32_t> vec; 850 vec.emplace_back(0); 851 vec.emplace_back(1); 852 vec.emplace_back(std::numeric_limits<uint32_t>::min()); 853 vec.emplace_back(std::numeric_limits<uint32_t>::max()); 854 855 // vector 856 g_writeCtx.seek(&g_writeCtx, 0); 857 msgOpt.add_len_repeated_packed_unsigned_vint(vec); 858 printf("add_len_repeated_packed_unsigned_vint(vec):\n"); 859 for (uint32_t i = 0; i < g_writePos; i++) { 860 printf("%02X ", g_buf[i]); 861 } 862 printf("\n"); 863 864 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 865 int count = msgProtobuf.len_repeated_packed_unsigned_vint_size(); 866 ASSERT_EQ(count, static_cast<int>(vec.size())); 867 for (int i = 0; i < count; i++) { 868 ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vec[i]); 869 } 870 871 // array 872 msgOpt.add_len_repeated_packed_unsigned_vint(array, sizeof(array) / sizeof(array[0])); 873 printf("add_len_repeated_packed_unsigned_vint(array):\n"); 874 for (uint32_t i = 0; i < g_writePos; i++) { 875 printf("%02X ", g_buf[i]); 876 } 877 printf("\n"); 878 879 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 880 int countAll = msgProtobuf.len_repeated_packed_unsigned_vint_size(); 881 ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0]))); 882 for (int i = 0; i < count; i++) { 883 ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vec[i]); 884 } 885 for (int i = count; i < countAll; i++) { 886 ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), array[i - count]); 887 } 888} 889 890HWTEST_F(BaseMessageUnittest, SetRepeatedPackedFixed64, TestSize.Level1) 891{ 892 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 893 ExampleMessage msgProtobuf; 894 const uint64_t array[] = {0, 1, 895 std::numeric_limits<uint64_t>::min(), 896 std::numeric_limits<uint64_t>::max()}; 897 std::vector<uint64_t> vec; 898 vec.emplace_back(0); 899 vec.emplace_back(1); 900 vec.emplace_back(std::numeric_limits<uint64_t>::min()); 901 vec.emplace_back(std::numeric_limits<uint64_t>::max()); 902 903 // vector 904 g_writeCtx.seek(&g_writeCtx, 0); 905 msgOpt.add_len_repeated_packed_fixed(vec); 906 printf("add_len_repeated_packed_fixed(vec):\n"); 907 for (uint32_t i = 0; i < g_writePos; i++) { 908 printf("%02X ", g_buf[i]); 909 } 910 printf("\n"); 911 912 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 913 int count = msgProtobuf.len_repeated_packed_fixed_size(); 914 ASSERT_EQ(count, static_cast<int>(vec.size())); 915 for (int i = 0; i < count; i++) { 916 ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vec[i]); 917 } 918 919 // array 920 msgOpt.add_len_repeated_packed_fixed(array, sizeof(array) / sizeof(array[0])); 921 printf("add_len_repeated_packed_fixed(array):\n"); 922 for (uint32_t i = 0; i < g_writePos; i++) { 923 printf("%02X ", g_buf[i]); 924 } 925 printf("\n"); 926 927 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 928 int countAll = msgProtobuf.len_repeated_packed_fixed_size(); 929 ASSERT_EQ(countAll, static_cast<int>(vec.size() + sizeof(array) / sizeof(array[0]))); 930 for (int i = 0; i < count; i++) { 931 ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vec[i]); 932 } 933 for (int i = count; i < countAll; i++) { 934 ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), array[i - count]); 935 } 936} 937 938static const char BYTES_DATA[] = {0x00, 0x01, 0x02, 0xFD, 0xFE, 0xFF}; 939 940HWTEST_F(BaseMessageUnittest, SetBytes, TestSize.Level1) 941{ 942 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 943 ExampleMessage msgProtobuf; 944 945 g_writeCtx.seek(&g_writeCtx, 0); 946 msgOpt.set_len_bytes(BYTES_DATA, sizeof(BYTES_DATA)); 947 printf("set_len_bytes(void*, size_t):\n"); 948 for (uint32_t i = 0; i < g_writePos; i++) { 949 printf("%02X ", g_buf[i]); 950 } 951 printf("\n"); 952 953 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 954 ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA))); 955} 956 957HWTEST_F(BaseMessageUnittest, SetBytesCallback, TestSize.Level1) 958{ 959 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 960 ExampleMessage msgProtobuf; 961 962 // bytes stram 963 g_writeCtx.seek(&g_writeCtx, 0); 964 msgOpt.set_len_bytes( 965 [](RandomWriteCtx* ctx) -> int32_t { 966 uint8_t* memory = nullptr; 967 uint32_t offset = 0; 968 if (ctx->getMemory(ctx, sizeof(BYTES_DATA), &memory, &offset)) { 969 if (memcpy_s(memory, sizeof(BYTES_DATA), BYTES_DATA, sizeof(BYTES_DATA)) == EOK) { 970 ctx->seek(ctx, offset + sizeof(BYTES_DATA)); 971 return sizeof(BYTES_DATA); 972 } 973 } 974 return 0; 975 }); 976 printf("set_len_bytes(CallbackFunc(bytes)):\n"); 977 for (uint32_t i = 0; i < g_writePos; i++) { 978 printf("%02X ", g_buf[i]); 979 } 980 printf("\n"); 981 982 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 983 ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA))); 984 985 // protobufOpt message 986 g_writeCtx.seek(&g_writeCtx, 0); 987 msgOpt.set_len_bytes( 988 [](RandomWriteCtx* ctx) -> int32_t { 989 ProtoEncoder::SubMessage subMsg(ctx); 990 subMsg.set_vint_int32(std::numeric_limits<int32_t>::max()); 991 subMsg.set_vint_int64(std::numeric_limits<int64_t>::max()); 992 subMsg.set_vint_uint32(std::numeric_limits<uint32_t>::max()); 993 subMsg.set_vint_uint64(std::numeric_limits<uint64_t>::max()); 994 return subMsg.Finish(); 995 }); 996 printf("set_len_bytes(CallbackFunc(message)):\n"); 997 for (uint32_t i = 0; i < g_writePos; i++) { 998 printf("%02X ", g_buf[i]); 999 } 1000 printf("\n"); 1001 1002 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1003 auto& bytes = msgProtobuf.len_bytes(); 1004 SubMessage subMsgProtobuf; 1005 ASSERT_TRUE(subMsgProtobuf.ParseFromArray(bytes.data(), bytes.size())); 1006 ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max()); 1007 ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max()); 1008 ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max()); 1009 ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max()); 1010} 1011 1012HWTEST_F(BaseMessageUnittest, AddBytes, TestSize.Level1) 1013{ 1014 const char data[] = {0x00, 0x01, 0x02, 0xFD, 0xFE, 0xFF}; 1015 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1016 ExampleMessage msgProtobuf; 1017 1018 // bytes stram 1019 g_writeCtx.seek(&g_writeCtx, 0); 1020 RandomWriteCtx* writeCtx = msgOpt.startAdd_len_bytes(); 1021 uint8_t* memory = nullptr; 1022 uint32_t offset = 0; 1023 if (writeCtx->getMemory(writeCtx, sizeof(data), &memory, &offset)) { 1024 if (memcpy_s(memory, sizeof(data), data, sizeof(data)) != EOK) { 1025 writeCtx->seek(writeCtx, offset + sizeof(data)); 1026 } 1027 } 1028 msgOpt.finishAdd_len_bytes(sizeof(data)); 1029 printf("Add_LEN_bytes(Customize(bytes)):\n"); 1030 for (uint32_t i = 0; i < g_writePos; i++) { 1031 printf("%02X ", g_buf[i]); 1032 } 1033 printf("\n"); 1034 1035 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1036 ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&data[0], sizeof(data))); 1037 1038 // protobufOpt message 1039 g_writeCtx.seek(&g_writeCtx, 0); 1040 writeCtx = msgOpt.startAdd_len_bytes(); 1041 ProtoEncoder::SubMessage subMsg(writeCtx); 1042 subMsg.set_vint_int32(std::numeric_limits<int32_t>::max()); 1043 subMsg.set_vint_int64(std::numeric_limits<int64_t>::max()); 1044 subMsg.set_vint_uint32(std::numeric_limits<uint32_t>::max()); 1045 subMsg.set_vint_uint64(std::numeric_limits<uint64_t>::max()); 1046 msgOpt.finishAdd_len_bytes(subMsg.Finish()); 1047 printf("Add_LEN_bytes(Customize(message)):\n"); 1048 for (uint32_t i = 0; i < g_writePos; i++) { 1049 printf("%02X ", g_buf[i]); 1050 } 1051 printf("\n"); 1052 1053 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1054 auto& bytes = msgProtobuf.len_bytes(); 1055 SubMessage subMsgProtobuf; 1056 ASSERT_TRUE(subMsgProtobuf.ParseFromArray(bytes.data(), bytes.size())); 1057 ASSERT_EQ(subMsgProtobuf.vint_int32(), std::numeric_limits<int32_t>::max()); 1058 ASSERT_EQ(subMsgProtobuf.vint_int64(), std::numeric_limits<int64_t>::max()); 1059 ASSERT_EQ(subMsgProtobuf.vint_uint32(), std::numeric_limits<uint32_t>::max()); 1060 ASSERT_EQ(subMsgProtobuf.vint_uint64(), std::numeric_limits<uint64_t>::max()); 1061} 1062 1063HWTEST_F(BaseMessageUnittest, SetAll, TestSize.Level1) 1064{ 1065 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1066 ExampleMessage msgProtobuf; 1067 1068 g_writeCtx.seek(&g_writeCtx, 0); 1069 msgOpt.set_vint_int32(1); 1070 msgOpt.set_vint_int64(1); 1071 msgOpt.set_vint_uint32(1); 1072 msgOpt.set_vint_uint64(1); 1073 msgOpt.set_vint_sint32(1); 1074 msgOpt.set_vint_sint64(1); 1075 msgOpt.set_vint_bool(true); 1076 msgOpt.set_vint_enum(ProtoEncoder::NUM::ONE); 1077 msgOpt.set_i64_fixed64(1); 1078 msgOpt.set_i64_sfixed64(1); 1079 msgOpt.set_i64_double(1); 1080 1081 const std::string str = "this is test."; 1082 msgOpt.set_len_string(str); 1083 msgOpt.set_len_bytes(BYTES_DATA, sizeof(BYTES_DATA)); 1084 1085 ProtoEncoder::SubMessage* msgSub = msgOpt.mutable_len_sub(); 1086 ASSERT_TRUE(msgSub != nullptr); 1087 msgSub->set_vint_int32(1); 1088 msgSub->set_vint_int64(1); 1089 msgSub->set_vint_uint32(1); 1090 msgSub->set_vint_uint64(1); 1091 1092 const int32_t arraySigned[] = {0, 1, 1093 std::numeric_limits<int32_t>::min(), 1094 std::numeric_limits<int32_t>::max()}; 1095 std::vector<int32_t> vecSigned; 1096 vecSigned.emplace_back(0); 1097 vecSigned.emplace_back(1); 1098 vecSigned.emplace_back(std::numeric_limits<int32_t>::min()); 1099 vecSigned.emplace_back(std::numeric_limits<int32_t>::max()); 1100 msgOpt.add_len_repeated_packed_signed_vint(vecSigned); 1101 msgOpt.add_len_repeated_packed_signed_vint(arraySigned, sizeof(arraySigned) / sizeof(arraySigned[0])); 1102 1103 const uint32_t arrayUnsigned[] = {0, 1, 1104 std::numeric_limits<uint32_t>::min(), 1105 std::numeric_limits<uint32_t>::max()}; 1106 std::vector<uint32_t> vecUnsigned; 1107 vecUnsigned.emplace_back(0); 1108 vecUnsigned.emplace_back(1); 1109 vecUnsigned.emplace_back(std::numeric_limits<uint32_t>::min()); 1110 vecUnsigned.emplace_back(std::numeric_limits<uint32_t>::max()); 1111 msgOpt.add_len_repeated_packed_unsigned_vint(vecUnsigned); 1112 msgOpt.add_len_repeated_packed_unsigned_vint(arrayUnsigned, sizeof(arrayUnsigned) / sizeof(arrayUnsigned[0])); 1113 1114 const uint64_t arrayFixed[] = {0, 1, 1115 std::numeric_limits<uint64_t>::min(), 1116 std::numeric_limits<uint64_t>::max()}; 1117 std::vector<uint64_t> vecFixed; 1118 vecFixed.emplace_back(0); 1119 vecFixed.emplace_back(1); 1120 vecFixed.emplace_back(std::numeric_limits<uint64_t>::min()); 1121 vecFixed.emplace_back(std::numeric_limits<uint64_t>::max()); 1122 msgOpt.add_len_repeated_packed_fixed(vecFixed); 1123 msgOpt.add_len_repeated_packed_fixed(arrayFixed, sizeof(arrayFixed) / sizeof(arrayFixed[0])); 1124 1125 msgOpt.set_i32_fixed32(1); 1126 msgOpt.set_i32_sfixed32(1); 1127 msgOpt.set_i32_float(1); 1128 1129 msgOpt.set_oneof_fixed64(1); 1130 msgOpt.set_oneof_string(str); 1131 msgSub = msgOpt.mutable_oneof_sub(); 1132 ASSERT_TRUE(msgSub != nullptr); 1133 msgSub->set_vint_int32(1); 1134 msgSub->set_vint_int64(1); 1135 msgSub->set_vint_uint32(1); 1136 msgSub->set_vint_uint64(1); 1137 1138 ASSERT_EQ((uint32_t)msgOpt.Finish(), g_writePos); 1139 printf("SetAll size(%" PRIu32 "):\n", g_writePos); 1140 for (uint32_t i = 0; i < g_writePos; i++) { 1141 printf("%02X ", g_buf[i]); 1142 } 1143 printf("\n"); 1144 1145 // check result by protobuf 1146 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1147 1148 ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1); 1149 ASSERT_EQ(msgProtobuf.vint_int64(), (int64_t)1); 1150 ASSERT_EQ(msgProtobuf.vint_uint32(), (uint32_t)1); 1151 ASSERT_EQ(msgProtobuf.vint_uint64(), (uint64_t)1); 1152 ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)1); 1153 ASSERT_EQ(msgProtobuf.vint_sint64(), (int64_t)1); 1154 ASSERT_EQ(msgProtobuf.vint_sint32(), (int32_t)1); 1155 ASSERT_TRUE(msgProtobuf.vint_bool()); 1156 ASSERT_EQ(msgProtobuf.vint_enum(), NUM::ONE); 1157 1158 ASSERT_EQ(msgProtobuf.i64_fixed64(), (uint64_t)1); 1159 ASSERT_EQ(msgProtobuf.i64_sfixed64(), (int64_t)1); 1160 ASSERT_EQ(msgProtobuf.i64_double(), (double)1); 1161 1162 ASSERT_EQ(msgProtobuf.len_string(), str); 1163 ASSERT_EQ(msgProtobuf.len_bytes(), std::string(&BYTES_DATA[0], sizeof(BYTES_DATA))); 1164 1165 ASSERT_TRUE(msgProtobuf.has_len_sub()); 1166 SubMessage subMsgProtobuf = msgProtobuf.len_sub(); 1167 ASSERT_EQ(subMsgProtobuf.vint_int32(), (int32_t)1); 1168 ASSERT_EQ(subMsgProtobuf.vint_int64(), (int64_t)1); 1169 ASSERT_EQ(subMsgProtobuf.vint_uint32(), (uint32_t)1); 1170 ASSERT_EQ(subMsgProtobuf.vint_uint64(), (uint64_t)1); 1171 1172 int countAll = msgProtobuf.len_repeated_packed_signed_vint_size(); 1173 ASSERT_EQ(countAll, static_cast<int>(vecSigned.size() + sizeof(arraySigned) / sizeof(arraySigned[0]))); 1174 for (size_t i = 0; i < vecSigned.size(); i++) { 1175 ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), vecSigned[i]); 1176 } 1177 for (size_t i = vecSigned.size(); i < static_cast<size_t>(countAll); i++) { 1178 ASSERT_EQ(msgProtobuf.len_repeated_packed_signed_vint(i), arraySigned[i - vecSigned.size()]); 1179 } 1180 1181 countAll = msgProtobuf.len_repeated_packed_unsigned_vint_size(); 1182 ASSERT_EQ(countAll, static_cast<int>(vecUnsigned.size() + sizeof(arrayUnsigned) / sizeof(arrayUnsigned[0]))); 1183 for (size_t i = 0; i < vecUnsigned.size(); i++) { 1184 ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), vecUnsigned[i]); 1185 } 1186 for (size_t i = vecUnsigned.size(); i < static_cast<size_t>(countAll); i++) { 1187 ASSERT_EQ(msgProtobuf.len_repeated_packed_unsigned_vint(i), arrayUnsigned[i - vecUnsigned.size()]); 1188 } 1189 1190 countAll = msgProtobuf.len_repeated_packed_fixed_size(); 1191 ASSERT_EQ(countAll, static_cast<int>(vecFixed.size() + sizeof(arrayFixed) / sizeof(arrayFixed[0]))); 1192 for (size_t i = 0; i < vecFixed.size(); i++) { 1193 ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), vecFixed[i]); 1194 } 1195 for (size_t i = vecFixed.size(); i < static_cast<size_t>(countAll); i++) { 1196 ASSERT_EQ(msgProtobuf.len_repeated_packed_fixed(i), arrayFixed[i - vecFixed.size()]); 1197 } 1198 1199 ASSERT_EQ(msgProtobuf.i32_fixed32(), (uint32_t)1); 1200 ASSERT_EQ(msgProtobuf.i32_sfixed32(), (int32_t)1); 1201 ASSERT_EQ(msgProtobuf.i32_float(), (float)1); 1202 1203 // last one wins 1204 ASSERT_NE(msgProtobuf.oneof_fixed64(), (uint64_t)1); 1205 ASSERT_NE(msgProtobuf.oneof_string(), str); 1206 ASSERT_TRUE(msgProtobuf.has_oneof_sub()); 1207 subMsgProtobuf = msgProtobuf.oneof_sub(); 1208 ASSERT_EQ(subMsgProtobuf.vint_int32(), (int32_t)1); 1209 ASSERT_EQ(subMsgProtobuf.vint_int64(), (int64_t)1); 1210 ASSERT_EQ(subMsgProtobuf.vint_uint32(), (uint32_t)1); 1211 ASSERT_EQ(subMsgProtobuf.vint_uint64(), (uint64_t)1); 1212} 1213 1214HWTEST_F(BaseMessageUnittest, SubMessageLen0, TestSize.Level1) 1215{ 1216 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1217 ExampleMessage msgProtobuf; 1218 1219 // empty 1220 g_writeCtx.seek(&g_writeCtx, 0); 1221 ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub(); 1222 ASSERT_TRUE(subMsgOpt != nullptr); 1223 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 1224 printf("sub message length is 0:\n"); 1225 for (uint32_t i = 0; i < g_writePos; i++) { 1226 printf("%02X ", g_buf[i]); 1227 } 1228 printf("\n"); 1229 1230 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1231 ASSERT_TRUE(msgProtobuf.has_len_sub()); 1232 1233 g_writeCtx.seek(&g_writeCtx, 0); 1234 int subMsgOptRepeatedCount = 0; 1235 ProtoEncoder::SubMessage* subMsgOptRepeated = msgOpt.add_repeated_len_sub(); 1236 ASSERT_TRUE(subMsgOptRepeated != nullptr); 1237 subMsgOptRepeatedCount++; 1238 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 1239 printf("repeated sub message length is 0:\n"); 1240 for (uint32_t i = 0; i < g_writePos; i++) { 1241 printf("%02X ", g_buf[i]); 1242 } 1243 printf("\n"); 1244 1245 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1246 ASSERT_EQ(msgProtobuf.repeated_len_sub_size(), subMsgOptRepeatedCount); 1247 1248 subMsgOptRepeated = msgOpt.add_repeated_len_sub(); 1249 ASSERT_TRUE(subMsgOptRepeated != nullptr); 1250 subMsgOptRepeatedCount++; 1251 subMsgOptRepeated->set_vint_int32(1); 1252 msgOpt.set_vint_int32(std::numeric_limits<int32_t>::min()); 1253 printf("repeated sub message length > 0:\n"); 1254 for (uint32_t i = 0; i < g_writePos; i++) { 1255 printf("%02X ", g_buf[i]); 1256 } 1257 printf("\n"); 1258 1259 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1260 ASSERT_EQ(msgProtobuf.repeated_len_sub_size(), subMsgOptRepeatedCount); 1261 1262 // set bytes by callback 1263 g_writeCtx.seek(&g_writeCtx, 0); 1264 msgOpt.set_len_bytes( 1265 [](RandomWriteCtx* randomWriteCtx) -> int32_t { 1266 return 0; 1267 }); 1268 printf("set_len_bytes(CallbackFunc(len = 0)):\n"); 1269 for (uint32_t i = 0; i < g_writePos; i++) { 1270 printf("%02X ", g_buf[i]); 1271 } 1272 printf("\n"); 1273 1274 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1275 ASSERT_EQ(msgProtobuf.len_bytes(), std::string("")); 1276 1277 // add bytes 1278 g_writeCtx.seek(&g_writeCtx, 0); 1279 msgOpt.startAdd_len_bytes(); 1280 msgOpt.finishAdd_len_bytes(0); 1281 printf("Add_LEN_bytes(len = 0):\n"); 1282 for (uint32_t i = 0; i < g_writePos; i++) { 1283 printf("%02X ", g_buf[i]); 1284 } 1285 printf("\n"); 1286 1287 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1288 ASSERT_EQ(msgProtobuf.len_bytes(), std::string("")); 1289} 1290 1291HWTEST_F(BaseMessageUnittest, AutoFinishSubMessage, TestSize.Level1) 1292{ 1293 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1294 1295 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1296 msgOpt.set_i32_fixed32(1); 1297 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1298 msgOpt.set_i64_fixed64(1); 1299 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1300 msgOpt.set_vint_uint32(1); 1301 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1302 msgOpt.set_vint_sint32(1); 1303 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1304 msgOpt.set_len_string("\n"); 1305 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1306 ASSERT_TRUE(msgOpt.mutable_len_sub() != nullptr); 1307 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1308 ASSERT_TRUE(msgOpt.startAdd_len_bytes() != nullptr); 1309 msgOpt.finishAdd_len_bytes(0); 1310 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1311 msgOpt.set_len_bytes( 1312 [](RandomWriteCtx* randomWriteCtx) -> int32_t { 1313 return 0; 1314 }); 1315 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1316 std::vector<int32_t> arraySint32(1, -1); 1317 msgOpt.add_len_repeated_packed_signed_vint(arraySint32); 1318 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1319 std::vector<uint32_t> arrayUint32(1, 1); 1320 msgOpt.add_len_repeated_packed_unsigned_vint(arrayUint32); 1321 ASSERT_TRUE(msgOpt.add_repeated_example() != nullptr); 1322 std::vector<uint64_t> arrayfint64(1, 1); 1323 msgOpt.add_len_repeated_packed_fixed(arrayfint64); 1324 1325 ExampleMessage msgProtobuf; 1326 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1327 ASSERT_GT(msgProtobuf.repeated_example_size(), 0); 1328} 1329 1330HWTEST_F(BaseMessageUnittest, WriteFailedDrop, TestSize.Level1) 1331{ 1332 RandomWriteCtx writeCtx = { 1333 [](RandomWriteCtx*, uint32_t, uint8_t**, uint32_t*) -> bool { return false; }, 1334 [](RandomWriteCtx*, uint32_t) -> bool { return false; } 1335 }; 1336 1337 std::unique_ptr<ProtoEncoder::ExampleMessage> msgOpt = 1338 std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1339 msgOpt->set_i32_fixed32(1); 1340 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1341 1342 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1343 msgOpt->set_i64_fixed64(1); 1344 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1345 1346 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1347 msgOpt->set_vint_uint32(1); 1348 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1349 1350 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1351 msgOpt->set_vint_sint32(1); 1352 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1353 1354 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1355 msgOpt->set_len_string("\n"); 1356 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1357 1358 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1359 ASSERT_TRUE(msgOpt->mutable_len_sub() != nullptr); 1360 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1361 1362 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1363 ASSERT_TRUE(msgOpt->startAdd_len_bytes() == nullptr); 1364 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1365 1366 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1367 msgOpt->set_len_bytes( 1368 [](RandomWriteCtx* randomWriteCtx) -> int32_t { 1369 return 0; 1370 }); 1371 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1372 1373 std::vector<int32_t> arraySint32(1, -1); 1374 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1375 msgOpt->add_len_repeated_packed_signed_vint(arraySint32); 1376 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1377 1378 std::vector<uint32_t> arrayUint32(1, 1); 1379 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1380 msgOpt->add_len_repeated_packed_unsigned_vint(arrayUint32); 1381 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1382 1383 msgOpt = std::make_unique<ProtoEncoder::ExampleMessage>(&writeCtx); 1384 std::vector<uint64_t> arrayfint64(1, 1); 1385 msgOpt->add_len_repeated_packed_fixed(arrayfint64); 1386 ASSERT_EQ(msgOpt->Finish(), (int32_t)-1); 1387} 1388 1389HWTEST_F(BaseMessageUnittest, NoWrite, TestSize.Level1) 1390{ 1391 ProtoEncoder::ExampleMessage msgOpt(nullptr); 1392 1393 msgOpt.set_i32_fixed32(1); 1394 msgOpt.set_i64_fixed64(1); 1395 msgOpt.set_vint_uint32(1); 1396 msgOpt.set_vint_sint32(1); 1397 msgOpt.set_len_string("\n"); 1398 ASSERT_TRUE(msgOpt.startAdd_len_bytes() == nullptr); 1399 msgOpt.set_len_bytes(nullptr); 1400 msgOpt.set_len_bytes( 1401 [](RandomWriteCtx* randomWriteCtx) -> int32_t { 1402 return 0; 1403 }); 1404 1405 // arrayCount is 0 1406 msgOpt.add_len_repeated_packed_signed_vint(nullptr, 0); 1407 msgOpt.add_len_repeated_packed_unsigned_vint(nullptr, 0); 1408 msgOpt.add_len_repeated_packed_fixed(nullptr, 0); 1409 std::vector<int32_t> arraySint32(1, -1); 1410 msgOpt.add_len_repeated_packed_signed_vint(arraySint32); 1411 std::vector<uint32_t> arrayUint32(1, 1); 1412 msgOpt.add_len_repeated_packed_unsigned_vint(arrayUint32); 1413 std::vector<uint64_t> arrayfint64(1, 1); 1414 msgOpt.add_len_repeated_packed_fixed(arrayfint64); 1415 ASSERT_EQ(msgOpt.Finish(), (int32_t)-1); 1416} 1417 1418HWTEST_F(BaseMessageUnittest, SubMessageAlwaysAvailabe, TestSize.Level1) 1419{ 1420 ProtoEncoder::ExampleMessage msgOpt(nullptr); 1421 1422 ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub(); 1423 ASSERT_TRUE(subMsgOpt != nullptr); 1424 subMsgOpt->set_vint_int32(1); 1425 subMsgOpt->set_vint_int64(1); 1426 subMsgOpt->set_vint_uint32(1); 1427 subMsgOpt->set_vint_uint64(1); 1428 ASSERT_EQ(subMsgOpt->Finish(), (int32_t)-1); 1429 1430 ProtoEncoder::ExampleMessage* nested1 = msgOpt.add_repeated_example(); 1431 ASSERT_TRUE(nested1 != nullptr); 1432 ProtoEncoder::ExampleMessage* nested2 = nested1->add_repeated_example(); 1433 ASSERT_TRUE(nested2 != nullptr); 1434 ProtoEncoder::ExampleMessage* nested3 = nested2->add_repeated_example(); 1435 ASSERT_TRUE(nested3 != nullptr); 1436 1437 ASSERT_EQ(nested3->Finish(), (int32_t)-1); 1438 ASSERT_EQ(nested2->Finish(), (int32_t)-1); 1439 ASSERT_EQ(nested1->Finish(), (int32_t)-1); 1440 1441 msgOpt.set_vint_int32(1); 1442 ASSERT_EQ(msgOpt.Finish(), (int32_t)-1); 1443} 1444 1445HWTEST_F(BaseMessageUnittest, MessagePool, TestSize.Level1) 1446{ 1447 ProtoEncoder::MessagePool msgStack; 1448 ProtoEncoder::BaseMessage* pMsg = msgStack.Get(); 1449 ASSERT_TRUE(pMsg != nullptr); 1450 1451 msgStack.Reset(0); 1452 pMsg = msgStack.Get(); 1453 ASSERT_TRUE(pMsg != nullptr); 1454 1455 const uint32_t testRepeat = 1000; 1456 const uint32_t testDepth = 5; 1457 msgStack.Reset(testDepth); 1458 for (uint32_t i = 0; i < testRepeat; i++) { 1459 pMsg = msgStack.Get(); 1460 ASSERT_TRUE(pMsg != nullptr); 1461 msgStack.Release(); 1462 } 1463 1464 for (uint32_t i = 0; i < testRepeat; i++) { 1465 for (uint32_t j = 0; j < testDepth; j++) { 1466 pMsg = msgStack.Get(); 1467 ASSERT_TRUE(pMsg != nullptr); 1468 } 1469 for (uint32_t j = 0; j < testDepth; j++) { 1470 msgStack.Release(); 1471 } 1472 } 1473 1474 for (uint32_t i = 0; i < testRepeat; i++) { 1475 pMsg = msgStack.Get(); 1476 ASSERT_TRUE(pMsg != nullptr); 1477 } 1478 for (uint32_t i = 0; i < testRepeat; i++) { 1479 msgStack.Release(); 1480 } 1481 1482 msgStack.Reset(1); 1483 for (uint32_t i = 0; i < testDepth; i++) { 1484 pMsg = msgStack.Get(); 1485 ASSERT_TRUE(pMsg != nullptr); 1486 } 1487 ProtoEncoder::ExampleMessage* pExampleMsg = static_cast<ProtoEncoder::ExampleMessage*>(pMsg); 1488 g_writeCtx.seek(&g_writeCtx, 0); 1489 pExampleMsg->Reset(&g_writeCtx); 1490 pExampleMsg->set_vint_int32(1); 1491 ExampleMessage msgProtobuf; 1492 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1493 ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1); 1494 1495 msgStack.Reset(1); 1496 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx, &msgStack); 1497 g_writeCtx.seek(&g_writeCtx, 0); 1498 ProtoEncoder::SubMessage* subMsgOpt = msgOpt.mutable_len_sub(); 1499 ASSERT_TRUE(subMsgOpt != nullptr); 1500 msgOpt.set_vint_int32(1); 1501 ASSERT_TRUE(msgProtobuf.ParseFromArray(g_buf, g_writePos)); 1502 ASSERT_TRUE(msgProtobuf.has_len_sub()); 1503 ASSERT_EQ(msgProtobuf.vint_int32(), (int32_t)1); 1504} 1505 1506// reference from https://perfetto.dev/docs/design-docs/protozero 1507// For the full code of the benchmark see /src/protozero/test/protozero_benchmark.cc 1508const int TEST_TIMES = 1000 * 100; 1509uint64_t g_fakeInputSimple[] = {0x12345678, 1510 0x90ABCDEF, 1511 0x11111111, 1512 0xFFFFFFFF, 1513 0x6666666666666666ULL, 1514 0x6666666666666666ULL, 1515 0x6666666666666666ULL, 1516 0x0066666666666666ULL}; 1517 1518HWTEST_F(BaseMessageUnittest, ProtobufferSimple, TestSize.Level1) 1519{ 1520 for (int count = 0; count < TEST_TIMES; count++) { 1521 int index = 0; 1522 ExampleMessage msgProtobuf; 1523 1524 msgProtobuf.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1525 msgProtobuf.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1526 msgProtobuf.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1527 msgProtobuf.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1528 msgProtobuf.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1529 1530 ASSERT_TRUE(msgProtobuf.SerializeToArray(&g_buf[0], SIZE_BUFFER) > 0); 1531 } 1532 printf("%d times\n", TEST_TIMES); 1533} 1534 1535HWTEST_F(BaseMessageUnittest, ProtoEncoderSimple, TestSize.Level1) 1536{ 1537 for (int count = 0; count < TEST_TIMES; count++) { 1538 int index = 0; 1539 g_writeCtx.seek(&g_writeCtx, 0); 1540 1541 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1542 1543 msgOpt.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1544 msgOpt.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1545 msgOpt.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1546 msgOpt.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1547 msgOpt.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1548 1549 ASSERT_TRUE(msgOpt.Finish() > 0); 1550 } 1551 printf("%d times\n", TEST_TIMES); 1552} 1553 1554HWTEST_F(BaseMessageUnittest, ProtobufferNested, TestSize.Level1) 1555{ 1556 for (int count = 0; count < TEST_TIMES; count++) { 1557 int index = 0; 1558 ExampleMessage msgProtobuf; 1559 1560 msgProtobuf.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1561 msgProtobuf.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1562 msgProtobuf.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1563 msgProtobuf.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1564 msgProtobuf.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1565 // fisrt nested 1566 ExampleMessage* nested1 = msgProtobuf.add_repeated_example(); 1567 ASSERT_TRUE(nested1 != nullptr); 1568 index = 0; 1569 nested1->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1570 nested1->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1571 nested1->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1572 nested1->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1573 nested1->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1574 // second nested 1575 ExampleMessage* nested2 = nested1->add_repeated_example(); 1576 ASSERT_TRUE(nested2 != nullptr); 1577 index = 0; 1578 nested2->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1579 nested2->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1580 nested2->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1581 nested2->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1582 nested2->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1583 // third nested 1584 ExampleMessage* nested3 = nested2->add_repeated_example(); 1585 ASSERT_TRUE(nested3 != nullptr); 1586 index = 0; 1587 nested3->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1588 nested3->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1589 nested3->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1590 nested3->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1591 nested3->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1592 1593 ASSERT_TRUE(msgProtobuf.SerializeToArray(&g_buf[0], SIZE_BUFFER) > 0); 1594 } 1595 printf("%d times\n", TEST_TIMES); 1596} 1597 1598HWTEST_F(BaseMessageUnittest, ProtoEncoderNested, TestSize.Level1) 1599{ 1600 for (int count = 0; count < TEST_TIMES; count++) { 1601 int index = 0; 1602 g_writeCtx.seek(&g_writeCtx, 0); 1603 1604 ProtoEncoder::ExampleMessage msgOpt(&g_writeCtx); 1605 1606 msgOpt.set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1607 msgOpt.set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1608 msgOpt.set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1609 msgOpt.set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1610 msgOpt.set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1611 // fisrt nested 1612 ProtoEncoder::ExampleMessage* nested1 = msgOpt.add_repeated_example(); 1613 ASSERT_TRUE(nested1 != nullptr); 1614 index = 0; 1615 nested1->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1616 nested1->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1617 nested1->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1618 nested1->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1619 nested1->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1620 // second nested 1621 ProtoEncoder::ExampleMessage* nested2 = nested1->add_repeated_example(); 1622 ASSERT_TRUE(nested2 != nullptr); 1623 index = 0; 1624 nested2->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1625 nested2->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1626 nested2->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1627 nested2->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1628 nested2->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1629 // third nested 1630 ProtoEncoder::ExampleMessage* nested3 = nested2->add_repeated_example(); 1631 ASSERT_TRUE(nested3 != nullptr); 1632 index = 0; 1633 nested3->set_vint_int32(static_cast<int32_t>(g_fakeInputSimple[index++])); 1634 nested3->set_vint_uint32(static_cast<uint32_t>(g_fakeInputSimple[index++])); 1635 nested3->set_vint_int64(static_cast<int64_t>(g_fakeInputSimple[index++])); 1636 nested3->set_vint_uint64(static_cast<uint64_t>(g_fakeInputSimple[index++])); 1637 nested3->set_len_string(reinterpret_cast<const char*>(&g_fakeInputSimple[index++])); 1638 1639 ASSERT_TRUE(msgOpt.Finish() > 0); 1640 } 1641 printf("%d times\n", TEST_TIMES); 1642} 1643} // namespace Profiler 1644} // namespace Developtools 1645} // namespace OHOS 1646