1 /* 2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd. 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 16 #include "netstack_log.h" 17 #include "gtest/gtest.h" 18 #include <cstring> 19 #include <iostream> 20 21 #include "local_socket_context.h" 22 #include "local_socket_exec.h" 23 #include "local_socket_server_context.h" 24 #include "multicast_get_loopback_context.h" 25 #include "multicast_get_ttl_context.h" 26 #include "multicast_membership_context.h" 27 #include "multicast_set_loopback_context.h" 28 #include "multicast_set_ttl_context.h" 29 #include "socket_exec.h" 30 #include "socket_exec_common.h" 31 32 #include "socks5.h" 33 #include "socks5_instance.h" 34 #include "socks5_none_method.h" 35 #include "socks5_passwd_method.h" 36 #include "socks5_package.h" 37 #include "socks5_utils.h" 38 39 class SocketTest : public testing::Test { 40 public: SetUpTestCase()41 static void SetUpTestCase() {} 42 TearDownTestCase()43 static void TearDownTestCase() {} 44 SetUp()45 virtual void SetUp() {} 46 TearDown()47 virtual void TearDown() {} 48 }; 49 50 namespace { 51 using namespace std; 52 using namespace testing::ext; 53 using namespace OHOS::NetStack; 54 using namespace OHOS::NetStack::Socket; 55 using namespace OHOS::NetStack::Socks5; 56 57 HWTEST_F(SocketTest, MulticastTest001, TestSize.Level1) 58 { 59 napi_env env = nullptr; 60 auto eventManager = std::make_shared<EventManager>(); 61 MulticastMembershipContext context(env, eventManager); 62 bool ret = SocketExec::ExecUdpAddMembership(&context); 63 EXPECT_EQ(ret, false); 64 } 65 66 HWTEST_F(SocketTest, MulticastTest002, TestSize.Level1) 67 { 68 napi_env env = nullptr; 69 auto eventManager = std::make_shared<EventManager>(); 70 MulticastMembershipContext context(env, eventManager); 71 bool ret = SocketExec::ExecUdpDropMembership(&context); 72 EXPECT_EQ(ret, false); 73 } 74 75 HWTEST_F(SocketTest, MulticastTest003, TestSize.Level1) 76 { 77 napi_env env = nullptr; 78 auto eventManager = std::make_shared<EventManager>(); 79 MulticastSetTTLContext context(env, eventManager); 80 bool ret = SocketExec::ExecSetMulticastTTL(&context); 81 EXPECT_EQ(ret, false); 82 } 83 84 HWTEST_F(SocketTest, MulticastTest004, TestSize.Level1) 85 { 86 napi_env env = nullptr; 87 auto eventManager = std::make_shared<EventManager>(); 88 MulticastGetTTLContext context(env, eventManager); 89 bool ret = SocketExec::ExecGetMulticastTTL(&context); 90 EXPECT_EQ(ret, false); 91 } 92 93 HWTEST_F(SocketTest, MulticastTest005, TestSize.Level1) 94 { 95 napi_env env = nullptr; 96 auto eventManager = std::make_shared<EventManager>(); 97 MulticastSetLoopbackContext context(env, eventManager); 98 bool ret = SocketExec::ExecSetLoopbackMode(&context); 99 EXPECT_EQ(ret, false); 100 } 101 102 HWTEST_F(SocketTest, MulticastTest006, TestSize.Level1) 103 { 104 napi_env env = nullptr; 105 auto eventManager = std::make_shared<EventManager>(); 106 MulticastGetLoopbackContext context(env, eventManager); 107 bool ret = SocketExec::ExecGetLoopbackMode(&context); 108 EXPECT_EQ(ret, false); 109 } 110 111 HWTEST_F(SocketTest, LocalSocketTest001, TestSize.Level1) 112 { 113 napi_env env = nullptr; 114 auto eventManager = std::make_shared<EventManager>(); 115 LocalSocketBindContext context(env, eventManager); 116 bool ret = LocalSocketExec::ExecLocalSocketBind(&context); 117 EXPECT_EQ(ret, false); 118 } 119 120 HWTEST_F(SocketTest, LocalSocketTest002, TestSize.Level1) 121 { 122 napi_env env = nullptr; 123 auto eventManager = std::make_shared<EventManager>(); 124 LocalSocketConnectContext context(env, eventManager); 125 bool ret = LocalSocketExec::ExecLocalSocketConnect(&context); 126 EXPECT_EQ(ret, false); 127 } 128 129 HWTEST_F(SocketTest, LocalSocketTest003, TestSize.Level1) 130 { 131 napi_env env = nullptr; 132 auto eventManager = std::make_shared<EventManager>(); 133 LocalSocketSendContext context(env, eventManager); 134 bool ret = LocalSocketExec::ExecLocalSocketSend(&context); 135 EXPECT_EQ(ret, false); 136 } 137 138 HWTEST_F(SocketTest, LocalSocketTest004, TestSize.Level1) 139 { 140 napi_env env = nullptr; 141 auto eventManager = std::make_shared<EventManager>(); 142 LocalSocketCloseContext context(env, eventManager); 143 bool ret = LocalSocketExec::ExecLocalSocketClose(&context); 144 EXPECT_EQ(ret, false); 145 } 146 147 HWTEST_F(SocketTest, LocalSocketTest005, TestSize.Level1) 148 { 149 napi_env env = nullptr; 150 auto eventManager = std::make_shared<EventManager>(); 151 LocalSocketGetStateContext context(env, eventManager); 152 bool ret = LocalSocketExec::ExecLocalSocketGetState(&context); 153 EXPECT_EQ(ret, true); 154 } 155 156 HWTEST_F(SocketTest, LocalSocketTest006, TestSize.Level1) 157 { 158 napi_env env = nullptr; 159 auto eventManager = std::make_shared<EventManager>(); 160 LocalSocketGetSocketFdContext context(env, eventManager); 161 bool ret = LocalSocketExec::ExecLocalSocketGetSocketFd(&context); 162 EXPECT_EQ(ret, true); 163 } 164 165 HWTEST_F(SocketTest, LocalSocketTest007, TestSize.Level1) 166 { 167 napi_env env = nullptr; 168 auto eventManager = std::make_shared<EventManager>(); 169 LocalSocketSetExtraOptionsContext context(env, eventManager); 170 bool ret = LocalSocketExec::ExecLocalSocketSetExtraOptions(&context); 171 EXPECT_EQ(ret, true); 172 } 173 174 HWTEST_F(SocketTest, LocalSocketTest008, TestSize.Level1) 175 { 176 napi_env env = nullptr; 177 auto eventManager = std::make_shared<EventManager>(); 178 LocalSocketGetExtraOptionsContext context(env, eventManager); 179 bool ret = LocalSocketExec::ExecLocalSocketGetExtraOptions(&context); 180 EXPECT_EQ(ret, false); 181 } 182 183 HWTEST_F(SocketTest, LocalSocketServerTest001, TestSize.Level1) 184 { 185 napi_env env = nullptr; 186 auto eventManager = std::make_shared<EventManager>(); 187 LocalSocketServerListenContext context(env, eventManager); 188 bool ret = LocalSocketExec::ExecLocalSocketServerListen(&context); 189 EXPECT_EQ(ret, false); 190 } 191 192 HWTEST_F(SocketTest, LocalSocketServerTest002, TestSize.Level1) 193 { 194 napi_env env = nullptr; 195 auto eventManager = std::make_shared<EventManager>(); 196 LocalSocketServerGetStateContext context(env, eventManager); 197 bool ret = LocalSocketExec::ExecLocalSocketServerGetState(&context); 198 EXPECT_EQ(ret, true); 199 } 200 201 HWTEST_F(SocketTest, LocalSocketServerTest003, TestSize.Level1) 202 { 203 napi_env env = nullptr; 204 auto eventManager = std::make_shared<EventManager>(); 205 LocalSocketServerSetExtraOptionsContext context(env, eventManager); 206 bool ret = LocalSocketExec::ExecLocalSocketServerSetExtraOptions(&context); 207 EXPECT_EQ(ret, false); 208 } 209 210 HWTEST_F(SocketTest, LocalSocketServerTest004, TestSize.Level1) 211 { 212 napi_env env = nullptr; 213 auto eventManager = std::make_shared<EventManager>(); 214 LocalSocketServerGetExtraOptionsContext context(env, eventManager); 215 bool ret = LocalSocketExec::ExecLocalSocketServerGetExtraOptions(&context); 216 EXPECT_EQ(ret, false); 217 } 218 219 HWTEST_F(SocketTest, LocalSocketServerTest005, TestSize.Level1) 220 { 221 napi_env env = nullptr; 222 auto eventManager = std::make_shared<EventManager>(); 223 LocalSocketServerSendContext context(env, eventManager); 224 bool ret = LocalSocketExec::ExecLocalSocketConnectionSend(&context); 225 EXPECT_EQ(ret, false); 226 } 227 228 HWTEST_F(SocketTest, LocalSocketServerTest006, TestSize.Level1) 229 { 230 napi_env env = nullptr; 231 auto eventManager = std::make_shared<EventManager>(); 232 LocalSocketServerCloseContext context(env, eventManager); 233 bool ret = LocalSocketExec::ExecLocalSocketConnectionClose(&context); 234 EXPECT_EQ(ret, false); 235 } 236 237 HWTEST_F(SocketTest, LocalSocketServerTest007, TestSize.Level1) 238 { 239 napi_env env = nullptr; 240 auto eventManager = std::make_shared<EventManager>(); 241 LocalSocketServerEndContext context(env, eventManager); 242 bool ret = LocalSocketExec::ExecLocalSocketServerEnd(&context); 243 EXPECT_EQ(ret, false); 244 } 245 246 // socks5 proxy test start 247 HWTEST_F(SocketTest, Socks5SocketTest001, TestSize.Level1) 248 { 249 napi_env env = nullptr; 250 auto eventManager = std::make_shared<EventManager>(); 251 ConnectContext context(env, eventManager); 252 bool ret = SocketExec::ExecConnect(&context); 253 EXPECT_EQ(ret, false); 254 255 context.proxyOptions = make_shared<ProxyOptions>(); 256 context.proxyOptions->type_ = ProxyType::SOCKS5; 257 ret = SocketExec::ExecConnect(&context); 258 EXPECT_EQ(ret, false); 259 } 260 261 HWTEST_F(SocketTest, Socks5SocketTest002, TestSize.Level1) 262 { 263 napi_env env = nullptr; 264 auto eventManager = std::make_shared<EventManager>(); 265 UdpSendContext context(env, eventManager); 266 context.parseOK_ = false; 267 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 268 269 context.parseOK_ = true; 270 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 271 272 int data = 1; 273 eventManager->data_ = &data; 274 shared_ptr<Socks5Instance> socks5Udp = make_shared<Socks5UdpInstance>(); 275 socks5Udp->options_ = make_shared<Socks5Option>(); 276 socks5Udp->SetSocks5Instance(socks5Udp); 277 eventManager->proxyData_ = socks5Udp; 278 context.proxyOptions = make_shared<ProxyOptions>(); 279 context.proxyOptions->type_ = ProxyType::NONE; 280 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 281 282 context.proxyOptions->type_ = ProxyType::SOCKS5; 283 EXPECT_FALSE(SocketExec::ExecUdpSend(&context)); 284 sleep(2); 285 } 286 287 HWTEST_F(SocketTest, SetSocks5OptionTest001, TestSize.Level1) 288 { 289 int32_t socketId = 1; 290 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 291 socks5Inst->SetSocks5Instance(socks5Inst); 292 shared_ptr<Socks5Option> opt = make_shared<Socks5Option>(); 293 socks5Inst->SetSocks5Option(opt); 294 EXPECT_FALSE(socks5Inst->options_ == nullptr); 295 } 296 297 HWTEST_F(SocketTest, DoConnectTest001, TestSize.Level1) 298 { 299 int32_t socketId = 1; 300 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 301 socks5Inst->options_ = make_shared<Socks5Option>(); 302 socks5Inst->SetSocks5Instance(socks5Inst); 303 auto ret = socks5Inst->DoConnect(Socks5Command::TCP_CONNECTION); 304 EXPECT_FALSE(ret); 305 EXPECT_FALSE(socks5Inst->IsConnected()); 306 } 307 308 HWTEST_F(SocketTest, RequestMethodTest001, TestSize.Level1) 309 { 310 int32_t socketId = 1; 311 vector<Socks5MethodType> methods = {Socks5MethodType::NO_AUTH, Socks5MethodType::PASSWORD}; 312 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 313 socks5Inst->options_ = make_shared<Socks5Option>(); 314 socks5Inst->SetSocks5Instance(socks5Inst); 315 auto ret = socks5Inst->RequestMethod(methods); 316 EXPECT_FALSE(ret); 317 } 318 319 HWTEST_F(SocketTest, CreateSocks5MethodByTypeTest001, TestSize.Level1) 320 { 321 int32_t socketId = 1; 322 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 323 socks5Inst->SetSocks5Instance(socks5Inst); 324 auto ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_AUTH); 325 EXPECT_FALSE(ret == nullptr); 326 327 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::PASSWORD); 328 EXPECT_FALSE(ret == nullptr); 329 330 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::GSSAPI); 331 EXPECT_TRUE(ret == nullptr); 332 333 ret = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_METHODS); 334 EXPECT_TRUE(ret == nullptr); 335 } 336 337 HWTEST_F(SocketTest, ConnectTest001, TestSize.Level1) 338 { 339 int32_t socketId = 1; 340 auto socks5TcpInst = make_shared<Socks5TcpInstance>(socketId); 341 socks5TcpInst->SetSocks5Instance(socks5TcpInst); 342 socks5TcpInst->options_ = make_shared<Socks5Option>(); 343 socks5TcpInst->state_ = Socks5AuthState::SUCCESS; 344 EXPECT_TRUE(socks5TcpInst->Connect()); 345 socks5TcpInst->state_ = Socks5AuthState::INIT; 346 EXPECT_FALSE(socks5TcpInst->Connect()); 347 } 348 349 HWTEST_F(SocketTest, ConnectTest002, TestSize.Level1) 350 { 351 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 352 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 353 socks5UdpInst->options_ = make_shared<Socks5Option>(); 354 socks5UdpInst->state_ = Socks5AuthState::SUCCESS; 355 EXPECT_TRUE(socks5UdpInst->Connect()); 356 socks5UdpInst->state_ = Socks5AuthState::INIT; 357 EXPECT_FALSE(socks5UdpInst->Connect()); 358 } 359 360 HWTEST_F(SocketTest, ConnectProxyTest001, TestSize.Level1) 361 { 362 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 363 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 364 socks5UdpInst->options_ = make_shared<Socks5Option>(); 365 EXPECT_FALSE(socks5UdpInst->ConnectProxy()); 366 } 367 368 HWTEST_F(SocketTest, RemoveHeaderTest001, TestSize.Level1) 369 { 370 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 371 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 372 void *data = nullptr; 373 size_t len = 2; 374 int af = AF_INET; 375 EXPECT_FALSE(socks5UdpInst->RemoveHeader(data, len, af)); 376 } 377 378 HWTEST_F(SocketTest, AddHeaderTest001, TestSize.Level1) 379 { 380 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 381 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 382 NetAddress dest; 383 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::IPv4)); 384 socks5UdpInst->dest_ = dest; 385 socks5UdpInst->AddHeader(); 386 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::IPv4); 387 } 388 389 HWTEST_F(SocketTest, AddHeaderTest002, TestSize.Level1) 390 { 391 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 392 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 393 NetAddress dest; 394 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::IPv6)); 395 socks5UdpInst->dest_ = dest; 396 socks5UdpInst->AddHeader(); 397 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::IPv6); 398 } 399 400 HWTEST_F(SocketTest, AddHeaderTest003, TestSize.Level1) 401 { 402 auto socks5UdpInst = make_shared<Socks5UdpInstance>(); 403 socks5UdpInst->SetSocks5Instance(socks5UdpInst); 404 NetAddress dest; 405 dest.SetFamilyByJsValue(static_cast<uint32_t>(NetAddress::Family::DOMAIN_NAME)); 406 socks5UdpInst->dest_ = dest; 407 socks5UdpInst->AddHeader(); 408 EXPECT_EQ(socks5UdpInst->dest_.GetFamily(), NetAddress::Family::DOMAIN_NAME); 409 } 410 411 HWTEST_F(SocketTest, NoAuthMethodTest001, TestSize.Level1) 412 { 413 int32_t socketId = 1; 414 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 415 socks5Inst->SetSocks5Instance(socks5Inst); 416 auto noAuthMethod = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::NO_AUTH); 417 noAuthMethod->socks5Inst_ = socks5Inst; 418 Socks5ProxyAddress proxyAddr; 419 EXPECT_TRUE(noAuthMethod->RequestAuth(socketId, "", "", proxyAddr)); 420 421 NetAddress dest; 422 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 423 424 dest.family_ = NetAddress::Family::IPv4; 425 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 426 427 dest.family_ = NetAddress::Family::IPv6; 428 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 429 430 dest.family_ = NetAddress::Family::DOMAIN_NAME; 431 EXPECT_FALSE(noAuthMethod->RequestProxy(socketId, Socks5Command::TCP_CONNECTION, dest, proxyAddr).first); 432 } 433 434 HWTEST_F(SocketTest, passWdMethodTest001, TestSize.Level1) 435 { 436 int32_t socketId = 1; 437 auto socks5Inst = make_shared<Socks5TcpInstance>(socketId); 438 socks5Inst->SetSocks5Instance(socks5Inst); 439 auto passWdMethod = socks5Inst->CreateSocks5MethodByType(Socks5MethodType::PASSWORD); 440 passWdMethod->socks5Inst_ = socks5Inst; 441 Socks5ProxyAddress proxyAddr; 442 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "", "pass", proxyAddr)); 443 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "user", "", proxyAddr)); 444 EXPECT_FALSE(passWdMethod->RequestAuth(socketId, "user", "pass", proxyAddr)); 445 } 446 447 HWTEST_F(SocketTest, Socks5PkgTest001, TestSize.Level1) 448 { 449 Socks5MethodRequest request; 450 Socks5MethodResponse response; 451 452 request.version_ = 1; 453 string serialized = request.Serialize(); 454 EXPECT_NE(serialized, ""); 455 456 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 457 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 458 } 459 460 HWTEST_F(SocketTest, Socks5PkgTest002, TestSize.Level1) 461 { 462 Socks5AuthRequest request; 463 Socks5AuthResponse response; 464 EXPECT_EQ(request.Serialize(), ""); 465 466 request.version_ = 1; 467 request.username_ = "user"; 468 request.password_ = "pass"; 469 string serialized = request.Serialize(); 470 EXPECT_NE(serialized, ""); 471 472 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 473 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 474 } 475 476 HWTEST_F(SocketTest, Socks5PkgTest003, TestSize.Level1) 477 { 478 Socks5ProxyRequest request; 479 Socks5ProxyResponse response; 480 EXPECT_EQ(request.Serialize(), ""); 481 482 request.version_ = 1; 483 request.cmd_ = Socks5Command::TCP_CONNECTION; 484 request.reserved_ = 1; 485 request.destPort_ = 1; 486 request.destAddr_ = "192.168.1.10"; 487 request.addrType_ = Socks5AddrType::IPV4; 488 string serialized = request.Serialize(); 489 EXPECT_NE(serialized, ""); 490 EXPECT_FALSE(response.Deserialize((uint8_t*) serialized.c_str(), 1)); 491 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 492 493 request.destAddr_ = "www.xxx.com"; 494 request.addrType_ = Socks5AddrType::DOMAIN_NAME; 495 string serialized2 = request.Serialize(); 496 EXPECT_NE(serialized2, ""); 497 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized2.c_str(), serialized2.size())); 498 499 request.destAddr_ = "fe80::100"; 500 request.addrType_ = Socks5AddrType::IPV6; 501 string serialized3 = request.Serialize(); 502 EXPECT_NE(serialized3, ""); 503 EXPECT_TRUE(response.Deserialize((uint8_t*) serialized3.c_str(), serialized3.size())); 504 } 505 506 HWTEST_F(SocketTest, Socks5PkgTest004, TestSize.Level1) 507 { 508 Socks5UdpHeader header; 509 EXPECT_EQ(header.Serialize(), ""); 510 511 header.reserved_ = 0; 512 header.frag_ = 0; 513 header.dstPort_ = 1; 514 515 header.destAddr_ = "192.168.1.10"; 516 header.addrType_ = Socks5AddrType::IPV4; 517 string serialized = header.Serialize(); 518 EXPECT_NE(serialized, ""); 519 EXPECT_FALSE(header.Deserialize((uint8_t*) serialized.c_str(), 1)); 520 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized.c_str(), serialized.size())); 521 522 header.destAddr_ = "www.xxx.com"; 523 header.addrType_ = Socks5AddrType::DOMAIN_NAME; 524 string serialized2 = header.Serialize(); 525 EXPECT_NE(serialized2, ""); 526 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized2.c_str(), serialized2.size())); 527 528 header.destAddr_ = "fe80::100"; 529 header.addrType_ = Socks5AddrType::IPV6; 530 string serialized3 = header.Serialize(); 531 EXPECT_NE(serialized3, ""); 532 EXPECT_TRUE(header.Deserialize((uint8_t*) serialized3.c_str(), serialized3.size())); 533 } 534 535 } // namespace