1 /* 2 * Copyright (c) 2023-2024 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 "gtest/gtest.h" 17 #include <cstring> 18 #include <iostream> 19 20 #include "close_context.h" 21 #include "connect_context.h" 22 #include "napi_utils.h" 23 #include "send_context.h" 24 #include "websocket_async_work.h" 25 #include "websocket_exec.h" 26 #include "websocket_module.h" 27 #ifdef NETSTACK_WEBSOCKETSERVER 28 #include "server_start_context.h" 29 #include "server_close_context.h" 30 #include "server_send_context.h" 31 #include "server_stop_context.h" 32 #include "list_all_connections_context.h" 33 #include "websocket_server_exec.h" 34 #endif // NETSTACK_WEBSOCKETSERVER 35 36 class WebSocketTest : public testing::Test { 37 public: SetUpTestCase()38 static void SetUpTestCase() {} 39 TearDownTestCase()40 static void TearDownTestCase() {} 41 SetUp()42 virtual void SetUp() {} 43 TearDown()44 virtual void TearDown() {} 45 }; 46 47 namespace { 48 using namespace testing::ext; 49 using namespace OHOS::NetStack; 50 using namespace OHOS::NetStack::Websocket; 51 52 HWTEST_F(WebSocketTest, WebSocketTest001, TestSize.Level1) 53 { 54 napi_env env = nullptr; 55 auto eventManager = std::make_shared<EventManager>(); 56 ConnectContext context(env, eventManager); 57 bool ret = WebSocketExec::ExecConnect(&context); 58 EXPECT_EQ(ret, false); 59 } 60 61 HWTEST_F(WebSocketTest, WebSocketTest002, TestSize.Level1) 62 { 63 napi_env env = nullptr; 64 auto eventManager = std::make_shared<EventManager>(); 65 SendContext context(env, eventManager); 66 bool ret = WebSocketExec::ExecSend(&context); 67 EXPECT_EQ(ret, false); 68 } 69 70 HWTEST_F(WebSocketTest, WebSocketTest003, TestSize.Level1) 71 { 72 napi_env env = nullptr; 73 auto eventManager = std::make_shared<EventManager>(); 74 CloseContext context(env, eventManager); 75 bool ret = WebSocketExec::ExecClose(&context); 76 EXPECT_EQ(ret, false); 77 } 78 79 HWTEST_F(WebSocketTest, WebSocketTest004, TestSize.Level1) 80 { 81 bool ret = WebSocketExec::ExecConnect(nullptr); 82 EXPECT_EQ(ret, false); 83 } 84 85 HWTEST_F(WebSocketTest, WebSocketTest005, TestSize.Level1) 86 { 87 napi_env env = nullptr; 88 auto eventManager = std::make_shared<EventManager>(); 89 ConnectContext context(env, eventManager); 90 context.caPath_ = "/etc/ssl/certs/test_ca.crt"; 91 bool ret = WebSocketExec::ExecConnect(&context); 92 EXPECT_EQ(ret, false); 93 } 94 95 HWTEST_F(WebSocketTest, WebSocketTest006, TestSize.Level1) 96 { 97 napi_env env = nullptr; 98 auto eventManager = std::make_shared<EventManager>(); 99 ConnectContext context(env, eventManager); 100 context.caPath_ = ""; 101 bool ret = WebSocketExec::ExecConnect(&context); 102 EXPECT_EQ(ret, false); 103 } 104 105 HWTEST_F(WebSocketTest, WebSocketTest007, TestSize.Level1) 106 { 107 napi_env env = nullptr; 108 auto eventManager = std::make_shared<EventManager>(); 109 ConnectContext context(env, eventManager); 110 111 context.url = "ws://123.123.123.123:9000"; 112 std::string myProtocol = "my-protocol"; 113 context.SetProtocol(myProtocol); 114 std::string getMyProtocol = context.GetProtocol(); 115 bool ret = WebSocketExec::ExecConnect(&context); 116 EXPECT_EQ(getMyProtocol, "my-protocol"); 117 EXPECT_GE(ret, 0); 118 } 119 120 HWTEST_F(WebSocketTest, WebSocketTest008, TestSize.Level1) 121 { 122 napi_env env = nullptr; 123 auto eventManager = std::make_shared<EventManager>(); 124 ConnectContext context(env, eventManager); 125 126 context.url = "ws://123.123.123.123:9000"; 127 context.SetWebsocketProxyType(WebsocketProxyType::USE_SPECIFIED); 128 std::string host = "192.168.147.60"; 129 int32_t port = 8888; 130 std::string exclusions = "www.httpbin.org"; 131 context.SetSpecifiedWebsocketProxy(host, port, exclusions); 132 std::string getHost; 133 uint32_t getPort; 134 std::string getExclusions; 135 context.GetSpecifiedWebsocketProxy(getHost, getPort, getExclusions); 136 bool ret = WebSocketExec::ExecConnect(&context); 137 EXPECT_EQ(getHost, "192.168.147.60"); 138 EXPECT_EQ(getPort, 8888); 139 EXPECT_EQ(getExclusions, "www.httpbin.org"); 140 EXPECT_GE(ret, 0); 141 } 142 143 #ifdef NETSTACK_WEBSOCKETSERVER 144 HWTEST_F(WebSocketTest, WebSocketTest009, TestSize.Level1) 145 { 146 napi_env env = nullptr; 147 auto eventManager = std::make_shared<EventManager>(); 148 ServerStartContext context(env, eventManager); 149 bool ret = WebSocketServerExec::ExecServerStart(&context); 150 EXPECT_EQ(ret, false); 151 } 152 153 HWTEST_F(WebSocketTest, WebSocketTest010, TestSize.Level1) 154 { 155 bool ret = WebSocketServerExec::ExecServerStart(nullptr); 156 EXPECT_EQ(ret, false); 157 } 158 159 HWTEST_F(WebSocketTest, WebSocketTest011, TestSize.Level1) 160 { 161 napi_env env = nullptr; 162 auto eventManager = std::make_shared<EventManager>(); 163 ServerStartContext context(env, eventManager); 164 context.SetPermissionDenied(true); 165 bool ret = WebSocketServerExec::ExecServerStart(&context); 166 EXPECT_EQ(ret, false); 167 } 168 169 HWTEST_F(WebSocketTest, WebSocketTest012, TestSize.Level1) 170 { 171 napi_env env = nullptr; 172 auto eventManager = std::make_shared<EventManager>(); 173 ServerSendContext context(env, eventManager); 174 bool ret = WebSocketServerExec::ExecServerSend(&context); 175 EXPECT_EQ(ret, false); 176 } 177 178 HWTEST_F(WebSocketTest, WebSocketTest013, TestSize.Level1) 179 { 180 bool ret = WebSocketServerExec::ExecServerSend(nullptr); 181 EXPECT_EQ(ret, false); 182 } 183 184 HWTEST_F(WebSocketTest, WebSocketTest014, TestSize.Level1) 185 { 186 napi_env env = nullptr; 187 auto eventManager = std::make_shared<EventManager>(); 188 ServerSendContext context(env, eventManager); 189 context.SetPermissionDenied(true); 190 bool ret = WebSocketServerExec::ExecServerSend(&context); 191 EXPECT_EQ(ret, false); 192 } 193 194 HWTEST_F(WebSocketTest, WebSocketTest015, TestSize.Level1) 195 { 196 napi_env env = nullptr; 197 auto eventManager = std::make_shared<EventManager>(); 198 ServerCloseContext context(env, eventManager); 199 bool ret = WebSocketServerExec::ExecServerClose(&context); 200 EXPECT_EQ(ret, false); 201 } 202 203 HWTEST_F(WebSocketTest, WebSocketTest016, TestSize.Level1) 204 { 205 bool ret = WebSocketServerExec::ExecServerClose(nullptr); 206 EXPECT_EQ(ret, false); 207 } 208 209 HWTEST_F(WebSocketTest, WebSocketTest017, TestSize.Level1) 210 { 211 napi_env env = nullptr; 212 auto eventManager = std::make_shared<EventManager>(); 213 ServerCloseContext context(env, eventManager); 214 context.SetPermissionDenied(true); 215 bool ret = WebSocketServerExec::ExecServerClose(&context); 216 EXPECT_EQ(ret, false); 217 } 218 219 HWTEST_F(WebSocketTest, WebSocketTest018, TestSize.Level1) 220 { 221 napi_env env = nullptr; 222 auto eventManager = std::make_shared<EventManager>(); 223 ServerStopContext context(env, eventManager); 224 bool ret = WebSocketServerExec::ExecServerStop(&context); 225 EXPECT_EQ(ret, false); 226 } 227 228 HWTEST_F(WebSocketTest, WebSocketTest019, TestSize.Level1) 229 { 230 bool ret = WebSocketServerExec::ExecServerStop(nullptr); 231 EXPECT_EQ(ret, false); 232 } 233 234 HWTEST_F(WebSocketTest, WebSocketTest020, TestSize.Level1) 235 { 236 napi_env env = nullptr; 237 auto eventManager = std::make_shared<EventManager>(); 238 ServerStopContext context(env, eventManager); 239 context.SetPermissionDenied(true); 240 bool ret = WebSocketServerExec::ExecServerStop(&context); 241 EXPECT_EQ(ret, false); 242 } 243 244 HWTEST_F(WebSocketTest, WebSocketTest021, TestSize.Level1) 245 { 246 napi_env env = nullptr; 247 auto eventManager = std::make_shared<EventManager>(); 248 ListAllConnectionsContext context(env, eventManager); 249 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 250 EXPECT_EQ(ret, false); 251 } 252 253 HWTEST_F(WebSocketTest, WebSocketTest022, TestSize.Level1) 254 { 255 bool ret = WebSocketServerExec::ExecListAllConnections(nullptr); 256 EXPECT_EQ(ret, false); 257 } 258 259 HWTEST_F(WebSocketTest, WebSocketTest023, TestSize.Level1) 260 { 261 napi_env env = nullptr; 262 auto eventManager = std::make_shared<EventManager>(); 263 ListAllConnectionsContext context(env, eventManager); 264 context.SetPermissionDenied(true); 265 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 266 EXPECT_EQ(ret, false); 267 } 268 269 HWTEST_F(WebSocketTest, WebSocketTest024, TestSize.Level1) 270 { 271 napi_env env = nullptr; 272 auto eventManager = std::make_shared<EventManager>(); 273 ConnectContext context(env, eventManager); 274 context.SetPermissionDenied(true); 275 bool ret = WebSocketExec::ExecConnect(&context); 276 EXPECT_EQ(ret, false); 277 } 278 279 HWTEST_F(WebSocketTest, WebSocketTest025, TestSize.Level1) 280 { 281 napi_env env = nullptr; 282 auto eventManager = std::make_shared<EventManager>(); 283 SendContext context(env, eventManager); 284 context.SetPermissionDenied(true); 285 bool ret = WebSocketExec::ExecSend(&context); 286 EXPECT_EQ(ret, false); 287 } 288 289 HWTEST_F(WebSocketTest, WebSocketTest026, TestSize.Level1) 290 { 291 napi_env env = nullptr; 292 auto eventManager = std::make_shared<EventManager>(); 293 CloseContext context(env, eventManager); 294 context.SetPermissionDenied(true); 295 bool ret = WebSocketExec::ExecClose(&context); 296 EXPECT_EQ(ret, false); 297 } 298 299 HWTEST_F(WebSocketTest, WebSocketTest027, TestSize.Level1) 300 { 301 napi_env env = nullptr; 302 auto eventManager = std::make_shared<EventManager>(); 303 ServerStartContext context(env, eventManager); 304 context.SetPermissionDenied(false); 305 bool ret = WebSocketServerExec::ExecServerStart(&context); 306 EXPECT_EQ(ret, false); 307 } 308 309 HWTEST_F(WebSocketTest, WebSocketTest028, TestSize.Level1) 310 { 311 napi_env env = nullptr; 312 auto eventManager = std::make_shared<EventManager>(); 313 ServerSendContext context(env, eventManager); 314 context.SetPermissionDenied(false); 315 bool ret = WebSocketServerExec::ExecServerSend(&context); 316 EXPECT_EQ(ret, false); 317 } 318 319 HWTEST_F(WebSocketTest, WebSocketTest029, TestSize.Level1) 320 { 321 napi_env env = nullptr; 322 auto eventManager = std::make_shared<EventManager>(); 323 ServerCloseContext context(env, eventManager); 324 context.SetPermissionDenied(false); 325 bool ret = WebSocketServerExec::ExecServerClose(&context); 326 EXPECT_EQ(ret, false); 327 } 328 329 HWTEST_F(WebSocketTest, WebSocketTest030, TestSize.Level1) 330 { 331 napi_env env = nullptr; 332 auto eventManager = std::make_shared<EventManager>(); 333 ServerStopContext context(env, eventManager); 334 context.SetPermissionDenied(false); 335 bool ret = WebSocketServerExec::ExecServerStop(&context); 336 EXPECT_EQ(ret, false); 337 } 338 339 HWTEST_F(WebSocketTest, WebSocketTest031, TestSize.Level1) 340 { 341 napi_env env = nullptr; 342 auto eventManager = std::make_shared<EventManager>(); 343 ListAllConnectionsContext context(env, eventManager); 344 context.SetPermissionDenied(false); 345 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 346 EXPECT_EQ(ret, false); 347 } 348 349 HWTEST_F(WebSocketTest, WebSocketTest032, TestSize.Level1) 350 { 351 napi_env env = nullptr; 352 auto eventManager = std::make_shared<EventManager>(); 353 ConnectContext context(env, eventManager); 354 context.SetPermissionDenied(false); 355 bool ret = WebSocketExec::ExecConnect(&context); 356 EXPECT_EQ(ret, false); 357 } 358 359 HWTEST_F(WebSocketTest, WebSocketTest033, TestSize.Level1) 360 { 361 napi_env env = nullptr; 362 auto eventManager = std::make_shared<EventManager>(); 363 SendContext context(env, eventManager); 364 context.SetPermissionDenied(false); 365 bool ret = WebSocketExec::ExecSend(&context); 366 EXPECT_EQ(ret, false); 367 } 368 369 HWTEST_F(WebSocketTest, WebSocketTest034, TestSize.Level1) 370 { 371 napi_env env = nullptr; 372 auto eventManager = std::make_shared<EventManager>(); 373 CloseContext context(env, eventManager); 374 context.SetPermissionDenied(false); 375 bool ret = WebSocketExec::ExecClose(&context); 376 EXPECT_EQ(ret, false); 377 } 378 379 HWTEST_F(WebSocketTest, WebSocketTest035, TestSize.Level1) 380 { 381 napi_env env = nullptr; 382 auto eventManager = std::make_shared<EventManager>(); 383 ServerStartContext context(env, eventManager); 384 context.SetPermissionDenied(true); 385 std::string ip = "0.0.0.0"; 386 context.SetServerIP(ip); 387 bool ret = WebSocketServerExec::ExecServerStart(&context); 388 EXPECT_EQ(ret, true); 389 } 390 391 HWTEST_F(WebSocketTest, WebSocketTest036, TestSize.Level1) 392 { 393 napi_env env = nullptr; 394 auto eventManager = std::make_shared<EventManager>(); 395 ServerStartContext context(env, eventManager); 396 context.SetPermissionDenied(true); 397 std::string ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"; 398 context.SetServerIP(ip); 399 bool ret = WebSocketServerExec::ExecServerStart(&context); 400 EXPECT_EQ(ret, true); 401 } 402 403 HWTEST_F(WebSocketTest, WebSocketTest037, TestSize.Level1) 404 { 405 napi_env env = nullptr; 406 auto eventManager = std::make_shared<EventManager>(); 407 ServerStartContext context(env, eventManager); 408 context.SetPermissionDenied(true); 409 std::string ip = "266.0.0.0"; 410 context.SetServerIP(ip); 411 bool ret = WebSocketServerExec::ExecServerStart(&context); 412 EXPECT_EQ(ret, false); 413 } 414 415 HWTEST_F(WebSocketTest, WebSocketTest038, TestSize.Level1) 416 { 417 napi_env env = nullptr; 418 auto eventManager = std::make_shared<EventManager>(); 419 ServerStartContext context(env, eventManager); 420 context.SetPermissionDenied(true); 421 std::string ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234"; 422 context.SetServerIP(ip); 423 bool ret = WebSocketServerExec::ExecServerStart(&context); 424 EXPECT_EQ(ret, false); 425 } 426 427 HWTEST_F(WebSocketTest, WebSocketTest039, TestSize.Level1) 428 { 429 napi_env env = nullptr; 430 auto eventManager = std::make_shared<EventManager>(); 431 ServerStartContext context(env, eventManager); 432 context.SetPermissionDenied(true); 433 std::string ip = "0.0.0.0"; 434 context.SetServerIP(ip); 435 uint32_t port = 444; 436 context.SetServerPort(port); 437 bool ret = WebSocketServerExec::ExecServerStart(&context); 438 EXPECT_EQ(ret, true); 439 } 440 441 HWTEST_F(WebSocketTest, WebSocketTest040, TestSize.Level1) 442 { 443 napi_env env = nullptr; 444 auto eventManager = std::make_shared<EventManager>(); 445 ServerStartContext context(env, eventManager); 446 context.SetPermissionDenied(true); 447 std::string ip = "0.0.0.0"; 448 context.SetServerIP(ip); 449 uint32_t port = 65555; 450 context.SetServerPort(port); 451 bool ret = WebSocketServerExec::ExecServerStart(&context); 452 EXPECT_EQ(ret, false); 453 } 454 455 HWTEST_F(WebSocketTest, WebSocketTest041, TestSize.Level1) 456 { 457 napi_env env = nullptr; 458 auto eventManager = std::make_shared<EventManager>(); 459 ServerStartContext context(env, eventManager); 460 context.SetPermissionDenied(true); 461 std::string ip = "0.0.0.0"; 462 context.SetServerIP(ip); 463 uint32_t port = 444; 464 context.SetServerPort(port); 465 uint32_t number = 15; 466 context.SetMaxConcurrentClientsNumber(number); 467 bool ret = WebSocketServerExec::ExecServerStart(&context); 468 EXPECT_EQ(ret, false); 469 } 470 471 HWTEST_F(WebSocketTest, WebSocketTest042, TestSize.Level1) 472 { 473 napi_env env = nullptr; 474 auto eventManager = std::make_shared<EventManager>(); 475 ServerStartContext context(env, eventManager); 476 std::string ip = "0.0.0.0"; 477 context.SetServerIP(ip); 478 uint32_t port = 444; 479 context.SetServerPort(port); 480 uint32_t number = 9; 481 context.SetMaxConcurrentClientsNumber(number); 482 uint32_t cnt = 15; 483 context.SetMaxConnectionsForOneClient(cnt); 484 bool ret = WebSocketServerExec::ExecServerStart(&context); 485 EXPECT_EQ(ret, false); 486 } 487 488 HWTEST_F(WebSocketTest, WebSocketTest043, TestSize.Level1) 489 { 490 napi_env env = nullptr; 491 auto eventManager = std::make_shared<EventManager>(); 492 ServerStartContext context(env, eventManager); 493 std::string ip = "0.0.0.0"; 494 context.SetServerIP(ip); 495 uint32_t port = 444; 496 context.SetServerPort(port); 497 uint32_t number = 9; 498 context.SetMaxConcurrentClientsNumber(number); 499 uint32_t cnt = 9; 500 context.SetMaxConnectionsForOneClient(cnt); 501 uint32_t cnt2 = 9; 502 context.SetMaxConnectionsForOneClient(cnt2); 503 bool ret = WebSocketServerExec::ExecServerStart(&context); 504 EXPECT_EQ(ret, true); 505 } 506 507 HWTEST_F(WebSocketTest, WebSocketTest044, TestSize.Level1) 508 { 509 napi_env env = nullptr; 510 auto eventManager = std::make_shared<EventManager>(); 511 ServerStartContext context(env, eventManager); 512 std::string ip = "0.0.0.0"; 513 context.SetServerIP(ip); 514 uint32_t port = 444; 515 context.SetServerPort(port); 516 uint32_t number = 9; 517 context.SetMaxConcurrentClientsNumber(number); 518 uint32_t cnt = 9; 519 context.SetMaxConnectionsForOneClient(cnt); 520 uint32_t cnt2 = 9; 521 context.SetMaxConnectionsForOneClient(cnt2); 522 bool ret = WebSocketServerExec::ExecServerStart(&context); 523 EXPECT_EQ(ret, true); 524 } 525 526 HWTEST_F(WebSocketTest, WebSocketTest045, TestSize.Level1) 527 { 528 napi_env env = nullptr; 529 auto eventManager = std::make_shared<EventManager>(); 530 ServerSendContext context(env, eventManager); 531 context.SetPermissionDenied(true); 532 uint32_t port = 444; 533 std::string ip = ""; 534 context.SetClientWebSocketConn(port, ip); 535 bool ret = WebSocketServerExec::ExecServerSend(&context); 536 EXPECT_EQ(ret, false); 537 } 538 539 HWTEST_F(WebSocketTest, WebSocketTest046, TestSize.Level1) 540 { 541 napi_env env = nullptr; 542 auto eventManager = std::make_shared<EventManager>(); 543 ServerSendContext context(env, eventManager); 544 context.SetPermissionDenied(true); 545 uint32_t port = 444; 546 std::string ip = "0.0.0.0"; 547 context.SetClientWebSocketConn(port, ip); 548 bool ret = WebSocketServerExec::ExecServerSend(&context); 549 EXPECT_EQ(ret, false); 550 } 551 552 HWTEST_F(WebSocketTest, WebSocketTest047, TestSize.Level1) 553 { 554 napi_env env = nullptr; 555 auto eventManager = std::make_shared<EventManager>(); 556 ServerCloseContext context(env, eventManager); 557 context.SetPermissionDenied(true); 558 std::shared_ptr<EventManager> sharedManager = nullptr; 559 context.SetSharedManager(sharedManager); 560 bool ret = WebSocketServerExec::ExecServerClose(&context); 561 EXPECT_EQ(ret, false); 562 } 563 564 HWTEST_F(WebSocketTest, WebSocketTest048, TestSize.Level1) 565 { 566 napi_env env = nullptr; 567 auto eventManager = std::make_shared<EventManager>(); 568 ServerCloseContext context(env, eventManager); 569 context.SetPermissionDenied(true); 570 context.connection.clientIP = ""; 571 context.connection.clientPort = 444; 572 bool ret = WebSocketServerExec::ExecServerClose(&context); 573 EXPECT_EQ(ret, false); 574 } 575 576 HWTEST_F(WebSocketTest, WebSocketTest049, TestSize.Level1) 577 { 578 napi_env env = nullptr; 579 auto eventManager = std::make_shared<EventManager>(); 580 ServerCloseContext context(env, eventManager); 581 context.SetPermissionDenied(true); 582 context.connection.clientIP = "0.0.0.0"; 583 context.connection.clientPort = 444; 584 bool ret = WebSocketServerExec::ExecServerClose(&context); 585 EXPECT_EQ(ret, false); 586 } 587 588 HWTEST_F(WebSocketTest, WebSocketTest050, TestSize.Level1) 589 { 590 napi_env env = nullptr; 591 auto eventManager = std::make_shared<EventManager>(); 592 ServerStopContext context(env, eventManager); 593 context.SetPermissionDenied(true); 594 std::shared_ptr<UserData> userData = nullptr; 595 eventManager->SetWebSocketUserData(userData); 596 context.SetSharedManager(eventManager); 597 bool ret = WebSocketServerExec::ExecServerStop(&context); 598 EXPECT_EQ(ret, false); 599 } 600 601 HWTEST_F(WebSocketTest, WebSocketTest051, TestSize.Level1) 602 { 603 napi_env env = nullptr; 604 auto eventManager = std::make_shared<EventManager>(); 605 ListAllConnectionsContext context(env, eventManager); 606 context.SetPermissionDenied(true); 607 context.SetSharedManager(nullptr); 608 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 609 EXPECT_EQ(ret, false); 610 } 611 612 HWTEST_F(WebSocketTest, WebSocketTest052, TestSize.Level1) 613 { 614 napi_env env = nullptr; 615 auto eventManager = std::make_shared<EventManager>(); 616 ListAllConnectionsContext context(env, eventManager); 617 context.SetPermissionDenied(true); 618 std::shared_ptr<UserData> userData = nullptr; 619 eventManager->SetWebSocketUserData(userData); 620 context.SetSharedManager(eventManager); 621 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 622 EXPECT_EQ(ret, false); 623 } 624 625 HWTEST_F(WebSocketTest, WebSocketTest053, TestSize.Level1) 626 { 627 napi_value ret = WebSocketServerExec::ListAllConnectionsCallback(nullptr); 628 EXPECT_EQ(ret, nullptr); 629 } 630 631 HWTEST_F(WebSocketTest, WebSocketTest054, TestSize.Level1) 632 { 633 napi_env env = nullptr; 634 auto eventManager = std::make_shared<EventManager>(); 635 ListAllConnectionsContext context(env, eventManager); 636 std::vector<OHOS::NetStack::Websocket::WebSocketConnection> connections; 637 context.SetAllConnections(connections); 638 napi_value connectionsArray = NapiUtils::CreateArray(context.GetEnv(), 0); 639 napi_value ret = WebSocketServerExec::ListAllConnectionsCallback(&context); 640 EXPECT_EQ(ret, connectionsArray); 641 } 642 643 HWTEST_F(WebSocketTest, WebSocketTest055, TestSize.Level1) 644 { 645 napi_env env = nullptr; 646 auto eventManager = std::make_shared<EventManager>(); 647 ServerStopContext context(env, eventManager); 648 context.SetSharedManager(nullptr); 649 napi_value ret = WebSocketServerExec::ServerStopCallback(&context); 650 EXPECT_EQ(ret, nullptr); 651 } 652 653 HWTEST_F(WebSocketTest, WebSocketTest056, TestSize.Level1) 654 { 655 napi_env env = nullptr; 656 auto eventManager = std::make_shared<EventManager>(); 657 ServerStopContext context(env, eventManager); 658 napi_value ret = WebSocketServerExec::ServerStopCallback(&context); 659 EXPECT_EQ(ret, nullptr); 660 } 661 662 HWTEST_F(WebSocketTest, WebSocketTest057, TestSize.Level1) 663 { 664 lws *wsi = nullptr; 665 WebSocketServerExec::OnConnect(wsi, nullptr); 666 EXPECT_EQ(wsi, nullptr); 667 } 668 669 HWTEST_F(WebSocketTest, WebSocketTest058, TestSize.Level1) 670 { 671 lws *wsi = nullptr; 672 auto eventManager = std::make_shared<EventManager>(); 673 WebSocketServerExec::OnConnect(wsi, eventManager.get()); 674 EXPECT_EQ(wsi, nullptr); 675 } 676 677 HWTEST_F(WebSocketTest, WebSocketTest059, TestSize.Level1) 678 { 679 lws *wsi = nullptr; 680 lws_close_status closeStatus = LWS_CLOSE_STATUS_NOSTATUS; 681 std::string closeReason = "The link is down, onError"; 682 WebSocketServerExec::OnServerClose(wsi, nullptr, closeStatus, closeReason); 683 EXPECT_EQ(wsi, nullptr); 684 } 685 686 HWTEST_F(WebSocketTest, WebSocketTest060, TestSize.Level1) 687 { 688 lws *wsi = nullptr; 689 auto eventManager = std::make_shared<EventManager>(); 690 lws_close_status closeStatus = LWS_CLOSE_STATUS_NOSTATUS; 691 std::string closeReason = "The link is down, onError"; 692 WebSocketServerExec::OnServerClose(wsi, eventManager.get(), closeStatus, closeReason); 693 EXPECT_EQ(closeStatus, LWS_CLOSE_STATUS_NOSTATUS); 694 } 695 696 HWTEST_F(WebSocketTest, WebSocketTest061, TestSize.Level1) 697 { 698 lws *wsi = nullptr; 699 void *data = nullptr; 700 size_t length = 0; 701 bool isBinary = false; 702 bool isFinal = false; 703 WebSocketServerExec::OnServerMessage(wsi, nullptr, data, length, isBinary, isFinal); 704 EXPECT_EQ(wsi, nullptr); 705 } 706 707 HWTEST_F(WebSocketTest, WebSocketTest062, TestSize.Level1) 708 { 709 lws *wsi = nullptr; 710 auto eventManager = std::make_shared<EventManager>(); 711 void *data = nullptr; 712 size_t length = 0; 713 bool isBinary = false; 714 bool isFinal = false; 715 WebSocketServerExec::OnServerMessage(wsi, eventManager.get(), data, length, isBinary, isFinal); 716 EXPECT_EQ(isBinary, false); 717 } 718 719 HWTEST_F(WebSocketTest, WebSocketTest063, TestSize.Level1) 720 { 721 int32_t code = 0; 722 WebSocketServerExec::OnServerError(nullptr, code); 723 EXPECT_EQ(code, 0); 724 } 725 726 HWTEST_F(WebSocketTest, WebSocketTest064, TestSize.Level1) 727 { 728 auto eventManager = std::make_shared<EventManager>(); 729 int32_t code = 0; 730 WebSocketServerExec::OnServerError(eventManager.get(), code); 731 EXPECT_EQ(code, 0); 732 } 733 734 HWTEST_F(WebSocketTest, WebSocketTest065, TestSize.Level1) 735 { 736 lws *wsi = nullptr; 737 void *data = nullptr; 738 size_t length = 0; 739 bool isBinary = true; 740 bool isFinal = true; 741 WebSocketServerExec::HandleServerRcvMessage(wsi, nullptr, data, length, isBinary, isFinal); 742 EXPECT_EQ(wsi, nullptr); 743 } 744 745 HWTEST_F(WebSocketTest, WebSocketTest066, TestSize.Level1) 746 { 747 lws *wsi = nullptr; 748 auto eventManager = std::make_shared<EventManager>(); 749 void *data = nullptr; 750 size_t length = 0; 751 bool isBinary = true; 752 bool isFinal = false; 753 WebSocketServerExec::HandleServerRcvMessage(wsi, eventManager.get(), data, length, isBinary, isFinal); 754 EXPECT_EQ(isFinal, false); 755 } 756 757 HWTEST_F(WebSocketTest, WebSocketTest067, TestSize.Level1) 758 { 759 lws *wsi = nullptr; 760 auto eventManager = std::make_shared<EventManager>(); 761 void *data = nullptr; 762 size_t length = 0; 763 bool isBinary = false; 764 bool isFinal = true; 765 WebSocketServerExec::HandleServerRcvMessage(wsi, eventManager.get(), data, length, isBinary, isFinal); 766 EXPECT_EQ(isFinal, true); 767 } 768 769 HWTEST_F(WebSocketTest, WebSocketTest068, TestSize.Level1) 770 { 771 lws *wsi = nullptr; 772 auto eventManager = std::make_shared<EventManager>(); 773 void *data = nullptr; 774 size_t length = 0; 775 bool isBinary = false; 776 bool isFinal = false; 777 WebSocketServerExec::HandleServerRcvMessage(wsi, eventManager.get(), data, length, isBinary, isFinal); 778 EXPECT_EQ(isFinal, false); 779 } 780 781 HWTEST_F(WebSocketTest, WebSocketTest069, TestSize.Level1) 782 { 783 lws *wsi = nullptr; 784 std::string msgFromManager = ""; 785 void *dataMsg = nullptr; 786 WebSocketServerExec::SetWebsocketMessage(wsi, nullptr, msgFromManager, dataMsg); 787 EXPECT_EQ(wsi, nullptr); 788 } 789 790 HWTEST_F(WebSocketTest, WebSocketTest070, TestSize.Level1) 791 { 792 lws *wsi = nullptr; 793 auto eventManager = std::make_shared<EventManager>(); 794 std::string msgFromManager = ""; 795 void *dataMsg = nullptr; 796 WebSocketServerExec::SetWebsocketMessage(wsi, eventManager.get(), msgFromManager, dataMsg); 797 EXPECT_NE(eventManager, nullptr); 798 } 799 800 HWTEST_F(WebSocketTest, WebSocketTest071, TestSize.Level1) 801 { 802 std::string clientId = "0.0.0.0:444"; 803 auto ret = WebSocketServerExec::GetClientWsi(clientId); 804 EXPECT_EQ(ret, nullptr); 805 } 806 807 HWTEST_F(WebSocketTest, WebSocketTest072, TestSize.Level1) 808 { 809 std::shared_ptr<UserData> userData = nullptr; 810 WebSocketServerExec::CloseAllConnection(userData); 811 EXPECT_EQ(userData, nullptr); 812 } 813 814 HWTEST_F(WebSocketTest, WebSocketTest073, TestSize.Level1) 815 { 816 lws_context *context = nullptr; 817 std::shared_ptr<UserData> userData = std::make_shared<UserData>(context); 818 WebSocketServerExec::CloseAllConnection(userData); 819 EXPECT_NE(userData, nullptr); 820 } 821 822 HWTEST_F(WebSocketTest, WebSocketTest074, TestSize.Level1) 823 { 824 napi_env env = nullptr; 825 auto eventManager = std::make_shared<EventManager>(); 826 ServerStartContext context(env, eventManager); 827 lws_context_creation_info info; 828 auto ret = WebSocketServerExec::FillServerCertPath(&context, info); 829 EXPECT_EQ(ret, true); 830 } 831 832 HWTEST_F(WebSocketTest, WebSocketTest075, TestSize.Level1) 833 { 834 napi_env env = nullptr; 835 auto eventManager = std::make_shared<EventManager>(); 836 ServerStartContext context(env, eventManager); 837 context.certPath_ = "/path/to/your/certificate.pem"; 838 lws_context_creation_info info; 839 auto ret = WebSocketServerExec::FillServerCertPath(&context, info); 840 EXPECT_EQ(ret, false); 841 } 842 843 HWTEST_F(WebSocketTest, WebSocketTest076, TestSize.Level1) 844 { 845 std::string id = "0.0.0.0:444"; 846 lws_context *context = nullptr; 847 std::shared_ptr<UserData> userData = std::make_shared<UserData>(context); 848 WebSocketConnection conn; 849 WebSocketServerExec::AddConnections(id, nullptr, userData, conn); 850 EXPECT_NE(userData, nullptr); 851 } 852 853 HWTEST_F(WebSocketTest, WebSocketTest077, TestSize.Level1) 854 { 855 std::string id = "0.0.0.0:444"; 856 lws_context *context = nullptr; 857 std::shared_ptr<UserData> userData = std::make_shared<UserData>(context); 858 WebSocketConnection conn; 859 userData->SetThreadStop(true); 860 WebSocketServerExec::AddConnections(id, nullptr, userData, conn); 861 EXPECT_EQ(userData->IsThreadStop(), true); 862 } 863 864 HWTEST_F(WebSocketTest, WebSocketTest078, TestSize.Level1) 865 { 866 std::string id = "0.0.0.0:444"; 867 lws_context *context = nullptr; 868 std::shared_ptr<UserData> userData = std::make_shared<UserData>(context); 869 WebSocketConnection conn; 870 lws_close_status status = LWS_CLOSE_STATUS_NOSTATUS; 871 std::string reason = "The link is down, onError"; 872 userData->Close(status, reason); 873 WebSocketServerExec::AddConnections(id, nullptr, userData, conn); 874 EXPECT_EQ(userData->IsClosed(), true); 875 } 876 877 HWTEST_F(WebSocketTest, WebSocketTest079, TestSize.Level1) 878 { 879 std::string id = "0.0.0.0:444"; 880 lws_context *context = nullptr; 881 std::shared_ptr<UserData> userData = std::make_shared<UserData>(context); 882 WebSocketServerExec::RemoveConnections(id, *userData); 883 EXPECT_NE(userData, nullptr); 884 } 885 #endif 886 887 HWTEST_F(WebSocketTest, WebSocketTest080, TestSize.Level1) 888 { 889 napi_env env = nullptr; 890 auto eventManager = std::make_shared<EventManager>(); 891 ConnectContext context(env, eventManager); 892 context.url = "wss://whale.tooly.top/ws"; 893 context.skipServerCertVerification_ = true; 894 EXPECT_TRUE(WebSocketExec::ExecConnect(&context)); 895 context.skipServerCertVerification_ = false; 896 EXPECT_FALSE(WebSocketExec::ExecConnect(&context)); 897 } 898 899 HWTEST_F(WebSocketTest, WebSocketTest081, TestSize.Level1) 900 { 901 napi_env env = nullptr; 902 auto eventManager = std::make_shared<EventManager>(); 903 ConnectContext context(env, eventManager); 904 std::string property = "skipServerCertVerification"; 905 napi_value obj = NapiUtils::CreateObject(context.GetEnv()); 906 context.ParseSkipServerCertVerify(obj); 907 NapiUtils::SetInt32Property(context.GetEnv(), obj, property, 0); 908 context.ParseSkipServerCertVerify(obj); 909 napi_value obj2 = NapiUtils::CreateObject(context.GetEnv()); 910 NapiUtils::SetBooleanProperty(context.GetEnv(), obj2, property, true); 911 context.ParseSkipServerCertVerify(obj2); 912 EXPECT_FALSE(WebSocketExec::ExecConnect(&context)); 913 } 914 } // namespace