1/* 2 * Copyright (c) 2022 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 "test.h" 17#include "napi/native_api.h" 18#include "napi/native_node_api.h" 19#include "tools/log.h" 20#include "js_url.h" 21#include <regex> 22#include <sstream> 23#include "securec.h" 24#include "unicode/stringpiece.h" 25#include "unicode/unistr.h" 26#include "native_module_url.h" 27 28#define ASSERT_CHECK_CALL(call) \ 29 { \ 30 ASSERT_EQ(call, napi_ok); \ 31 } 32 33#define ASSERT_CHECK_VALUE_TYPE(env, value, type) \ 34 { \ 35 napi_valuetype valueType = napi_undefined; \ 36 ASSERT_TRUE(value != nullptr); \ 37 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \ 38 ASSERT_EQ(valueType, type); \ 39 } 40 41napi_status DealNapiStrValue(napi_env env, const napi_value napiStr, std::string &result) 42{ 43 std::string buffer = ""; 44 size_t bufferSize = 0; 45 napi_status status = napi_ok; 46 status = napi_get_value_string_utf8(env, napiStr, nullptr, -1, &bufferSize); 47 buffer.reserve(bufferSize + 1); 48 buffer.resize(bufferSize); 49 if (status != napi_ok) { 50 HILOG_ERROR("can not get buffer size"); 51 return status; 52 } 53 if (bufferSize > 0) { 54 status = napi_get_value_string_utf8(env, napiStr, buffer.data(), bufferSize + 1, &bufferSize); 55 if (status != napi_ok) { 56 HILOG_ERROR("can not get buffer value"); 57 return status; 58 } 59 } 60 if (buffer.data() != nullptr) { 61 result = buffer; 62 } 63 return status; 64} 65 66napi_value StrToNapiValue(napi_env env, const std::string &result) 67{ 68 napi_value output = nullptr; 69 napi_create_string_utf8(env, result.c_str(), result.size(), &output); 70 return output; 71} 72 73static bool IsEscapeRange(const char ch) 74{ 75 if ((ch > 0 && ch < '*') || (ch > '*' && ch < '-') || (ch == '/') || 76 (ch > '9' && ch < 'A') || (ch > 'Z' && ch < '_') || (ch == '`') || (ch > 'z')) { 77 return true; 78 } 79 return false; 80} 81 82static std::string ReviseStr(std::string &str, std::string *reviseChar) 83{ 84 icu::StringPiece sp(str.c_str()); 85 icu::UnicodeString wstr = icu::UnicodeString::fromUTF8(sp); 86 const size_t lenStr = static_cast<size_t>(wstr.length()); 87 if (lenStr == 0) { 88 return ""; 89 } 90 std::string output = ""; 91 size_t numOfAscii = 128; // 128:Number of ASCII characters 92 size_t i = 0; 93 for (; i < lenStr; i++) { 94 auto charaEncode = static_cast<size_t>(wstr[i]); 95 if (charaEncode < numOfAscii) { 96 // 2:Defines the escape range of ASCII characters 97 if (IsEscapeRange(charaEncode)) { 98 output += reviseChar[charaEncode]; 99 } else { 100 output += str.substr(i, 1); 101 } 102 } else if (charaEncode <= 0x000007FF) { // Convert the Unicode code into two bytes 103 std::string output1 = reviseChar[0x000000C0 | (charaEncode / 64)]; // 64:the first byte 104 std::string output2 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)]; 105 output += output1 + output2; 106 } else if ((charaEncode >= 0x0000E000) || (charaEncode <= 0x0000D7FF)) { 107 std::string output1 = reviseChar[0x000000E0 | (charaEncode / 4096)]; // 4096:Acquisition method 108 std::string output2 = reviseChar[numOfAscii | ((charaEncode / 64) & 0x0000003F)]; // 64:second byte 109 std::string output3 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)]; 110 output += output1 + output2 + output3; 111 } else { 112 const size_t charaEncode1 = static_cast<size_t>(str[++i]) & 1023; // 1023:Convert codes 113 charaEncode = 65536 + (((charaEncode & 1023) << 10) | charaEncode1); // 65536:Specific transcoding 114 std::string output1 = reviseChar[0x000000F0 | (charaEncode / 262144)]; // 262144:the first byte 115 std::string output2 = reviseChar[numOfAscii | ((charaEncode / 4096) & 0x0000003F)]; // 4096:second byte 116 std::string output3 = reviseChar[numOfAscii | ((charaEncode / 64) & 0x0000003F)]; // 64:third byte 117 std::string output4 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)]; 118 output += output1 + output2 + output3 + output4; 119 } 120 } 121 return output; 122} 123 124napi_value ToString(napi_env env, std::vector<std::string> &searchParams) 125{ 126 std::string output = ""; 127 std::string reviseChar[256] = {""}; // 256:Array length 128 for (size_t i = 0; i < 256; ++i) { // 256:Array length 129 size_t j = i; 130 std::stringstream ioss; 131 std::string str1 = ""; 132 ioss << std::hex << j; 133 ioss >> str1; 134 transform(str1.begin(), str1.end(), str1.begin(), ::toupper); 135 if (i < 16) { // 16:Total number of 0-F 136 reviseChar[i] = '%' + ("0" + str1); 137 } else { 138 reviseChar[i] = '%' + str1; 139 } 140 } 141 reviseChar[0x20] = "+"; // 0x20:ASCII value of spaces 142 const size_t lenStr = searchParams.size(); 143 napi_value result = nullptr; 144 if (lenStr == 0) { 145 napi_create_string_utf8(env, output.c_str(), output.size(), &result); 146 return result; 147 } 148 std::string firstStrKey = ReviseStr(searchParams[0], reviseChar); 149 std::string firstStrValue = ReviseStr(searchParams[1], reviseChar); 150 output = firstStrKey + "=" + firstStrValue; 151 if (lenStr % 2 == 0) { // 2:Divisible by 2 152 size_t pos = 2; // 2:Initial Position 153 for (; pos < lenStr; pos += 2) { // 2:Searching for the number and number of keys and values 154 std::string strKey = ReviseStr(searchParams[pos], reviseChar); 155 std::string strValue = ReviseStr(searchParams[pos + 1], reviseChar); 156 output += +"&" + strKey + "=" + strValue; 157 } 158 } 159 napi_create_string_utf8(env, output.c_str(), output.size(), &result); 160 return result; 161} 162 163static std::vector<std::string> GetParamsStrig(napi_env env, const napi_value tempStr) 164{ 165 std::vector<std::string> vec; 166 size_t arraySize = 0; 167 uint32_t length = 0; 168 napi_get_array_length(env, tempStr, &length); 169 napi_value napiStr = nullptr; 170 for (size_t i = 0; i < length; i++) { 171 napi_get_element(env, tempStr, i, &napiStr); 172 if (napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize) != napi_ok) { 173 HILOG_ERROR("can not get napiStr size"); 174 return vec; 175 } 176 if (arraySize > 0) { 177 std::string cstr = ""; 178 cstr.resize(arraySize); 179 if (napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize) != napi_ok) { 180 HILOG_ERROR("can not get napiStr size"); 181 return vec; 182 } 183 vec.push_back(cstr); 184 } else { 185 vec.push_back(""); 186 } 187 } 188 return vec; 189} 190 191HWTEST_F(NativeEngineTest, testUrlConstructs001, testing::ext::TestSize.Level0) 192{ 193 OHOS::Url::URL url("https://example.org:81/a/b/c?query#fragment"); 194 std::string output; 195 napi_env env = (napi_env)engine_; 196 DealNapiStrValue(env, url.GetPath(env), output); 197 ASSERT_STREQ(output.c_str(), "/a/b/c"); 198} 199 200HWTEST_F(NativeEngineTest, testUrlConstructs002, testing::ext::TestSize.Level0) 201{ 202 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 203 std::string output; 204 napi_env env = (napi_env)engine_; 205 DealNapiStrValue(env, url.GetPath(env), output); 206 ASSERT_STREQ(output.c_str(), "/directory/file"); 207} 208 209HWTEST_F(NativeEngineTest, testUrlConstructs003, testing::ext::TestSize.Level0) 210{ 211 OHOS::Url::URL url("../baz", "http://example.org/foo/bar"); 212 std::string output; 213 napi_env env = (napi_env)engine_; 214 DealNapiStrValue(env, url.GetPath(env), output); 215 ASSERT_STREQ(output.c_str(), "/baz"); 216} 217 218HWTEST_F(NativeEngineTest, testUrlConstructs004, testing::ext::TestSize.Level0) 219{ 220 OHOS::Url::URL url("/../sca/./path/path/../scasa/jjjjj", "http://www.example.com"); 221 std::string output; 222 napi_env env = (napi_env)engine_; 223 DealNapiStrValue(env, url.GetPath(env), output); 224 ASSERT_STREQ(output.c_str(), "/sca/path/scasa/jjjjj"); 225} 226 227HWTEST_F(NativeEngineTest, testUrlConstructs005, testing::ext::TestSize.Level0) 228{ 229 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 230 std::string output; 231 napi_env env = (napi_env)engine_; 232 DealNapiStrValue(env, url.GetScheme(env), output); 233 ASSERT_STREQ(output.c_str(), "http:"); 234} 235 236HWTEST_F(NativeEngineTest, testUrlConstructs006, testing::ext::TestSize.Level0) 237{ 238 OHOS::Url::URL base("http://www.example.com"); 239 OHOS::Url::URL url("//sca/./path/./scasa#", base); 240 std::string output; 241 napi_env env = (napi_env)engine_; 242 DealNapiStrValue(env, url.GetPath(env), output); 243 ASSERT_STREQ(output.c_str(), "/path/scasa"); 244} 245 246HWTEST_F(NativeEngineTest, testUrlConstructs007, testing::ext::TestSize.Level0) 247{ 248 OHOS::Url::URL base("http://www.example.com"); 249 OHOS::Url::URL url("/dire/query", base); 250 std::string output; 251 napi_env env = (napi_env)engine_; 252 DealNapiStrValue(env, url.GetPath(env), output); 253 ASSERT_STREQ(output.c_str(), "/dire/query"); 254} 255 256HWTEST_F(NativeEngineTest, testUrlConstructs008, testing::ext::TestSize.Level0) 257{ 258 OHOS::Url::URL base("http://www.example.com"); 259 OHOS::Url::URL url("foo/bar//fragment", base); 260 std::string output; 261 napi_env env = (napi_env)engine_; 262 DealNapiStrValue(env, url.GetPath(env), output); 263 ASSERT_STREQ(output.c_str(), "/foo/bar//fragment"); 264} 265 266HWTEST_F(NativeEngineTest, testUrlConstructs009, testing::ext::TestSize.Level0) 267{ 268 OHOS::Url::URL base("http://www.example.com"); 269 OHOS::Url::URL url("/../sca/./path/./s#casa", base); 270 std::string output; 271 napi_env env = (napi_env)engine_; 272 DealNapiStrValue(env, url.GetPath(env), output); 273 ASSERT_STREQ(output.c_str(), "/sca/path/s"); 274} 275 276HWTEST_F(NativeEngineTest, testUrlConstructs010, testing::ext::TestSize.Level0) 277{ 278 OHOS::Url::URL base("http://www.example.com"); 279 OHOS::Url::URL url("/../sca/./path/./sca?sa", base); 280 std::string output; 281 napi_env env = (napi_env)engine_; 282 DealNapiStrValue(env, url.GetPath(env), output); 283 ASSERT_STREQ(output.c_str(), "/sca/path/sca"); 284} 285 286HWTEST_F(NativeEngineTest, testUrlConstructs011, testing::ext::TestSize.Level0) 287{ 288 OHOS::Url::URL base("http://www.example.com"); 289 OHOS::Url::URL url("", base); 290 std::string output; 291 napi_env env = (napi_env)engine_; 292 DealNapiStrValue(env, url.GetPath(env), output); 293 ASSERT_STREQ(output.c_str(), "/"); 294} 295 296HWTEST_F(NativeEngineTest, testUrlConstructs012, testing::ext::TestSize.Level0) 297{ 298 OHOS::Url::URL url("file://\\/www.example.com"); 299 std::string output; 300 napi_env env = (napi_env)engine_; 301 DealNapiStrValue(env, url.GetScheme(env), output); 302 ASSERT_STREQ(output.c_str(), "file:"); 303} 304 305HWTEST_F(NativeEngineTest, testUrlConstructs013, testing::ext::TestSize.Level0) 306{ 307 OHOS::Url::URL url("file:///www.example.com"); 308 std::string output; 309 napi_env env = (napi_env)engine_; 310 DealNapiStrValue(env, url.GetScheme(env), output); 311 ASSERT_STREQ(output.c_str(), "file:"); 312} 313 314HWTEST_F(NativeEngineTest, testUrlConstructs014, testing::ext::TestSize.Level0) 315{ 316 OHOS::Url::URL url("http1://www.example.com"); 317 std::string output; 318 napi_env env = (napi_env)engine_; 319 DealNapiStrValue(env, url.GetScheme(env), output); 320 ASSERT_STREQ(output.c_str(), "http1:"); 321} 322 323HWTEST_F(NativeEngineTest, testUrlConstructs015, testing::ext::TestSize.Level0) 324{ 325 OHOS::Url::URL url("http2://www.example.com:22/adfee/kk?a=4#saf"); 326 std::string output; 327 napi_env env = (napi_env)engine_; 328 DealNapiStrValue(env, url.GetScheme(env), output); 329 ASSERT_STREQ(output.c_str(), "http2:"); 330} 331 332HWTEST_F(NativeEngineTest, testUrlConstructs016, testing::ext::TestSize.Level0) 333{ 334 OHOS::Url::URL url("http2://username:password@www.example.com:22/adfee/kk?a=4#saf"); 335 std::string output; 336 napi_env env = (napi_env)engine_; 337 DealNapiStrValue(env, url.GetScheme(env), output); 338 ASSERT_STREQ(output.c_str(), "http2:"); 339} 340 341HWTEST_F(NativeEngineTest, testUrlConstructs017, testing::ext::TestSize.Level0) 342{ 343 OHOS::Url::URL url("http://"); 344 napi_env env = (napi_env)engine_; 345 napi_value result = url.GetOnOrOff(env); 346 bool value = false; 347 napi_get_value_bool(env, result, &value); 348 ASSERT_FALSE(value); 349} 350 351HWTEST_F(NativeEngineTest, testUrlConstructs018, testing::ext::TestSize.Level0) 352{ 353 OHOS::Url::URL url("http://username:password@/adfee/kk?a=4#saf"); 354 napi_env env = (napi_env)engine_; 355 napi_value result = url.GetOnOrOff(env); 356 bool value = false; 357 napi_get_value_bool(env, result, &value); 358 ASSERT_FALSE(value); 359} 360 361HWTEST_F(NativeEngineTest, testUrlConstructs019, testing::ext::TestSize.Level0) 362{ 363 OHOS::Url::URL url("http://username:password@/adfee/kk?a=4#saf", ""); 364 napi_env env = (napi_env)engine_; 365 napi_value result = url.GetOnOrOff(env); 366 bool value = false; 367 napi_get_value_bool(env, result, &value); 368 ASSERT_FALSE(value); 369} 370 371HWTEST_F(NativeEngineTest, testUrlConstructs020, testing::ext::TestSize.Level0) 372{ 373 OHOS::Url::URL url("http://username:password@sda/adfee/kk?a=4#saf", "http://sads/sad"); 374 napi_env env = (napi_env)engine_; 375 napi_value result = url.GetOnOrOff(env); 376 bool value = false; 377 napi_get_value_bool(env, result, &value); 378 ASSERT_TRUE(value); 379} 380 381HWTEST_F(NativeEngineTest, testUrlConstructs021, testing::ext::TestSize.Level0) 382{ 383 OHOS::Url::URL url("//fdsa", "http://sad"); 384 napi_env env = (napi_env)engine_; 385 napi_value result = url.GetOnOrOff(env); 386 bool value = false; 387 napi_get_value_bool(env, result, &value); 388 ASSERT_TRUE(value); 389} 390 391HWTEST_F(NativeEngineTest, testUrlConstructs022, testing::ext::TestSize.Level0) 392{ 393 OHOS::Url::URL url("-http://username:password@/adfee/kk?a=4#saf"); 394 napi_env env = (napi_env)engine_; 395 napi_value result = url.GetOnOrOff(env); 396 bool value = false; 397 napi_get_value_bool(env, result, &value); 398 ASSERT_FALSE(value); 399} 400 401HWTEST_F(NativeEngineTest, testUrlConstructs023, testing::ext::TestSize.Level0) 402{ 403 OHOS::Url::URL base("http://www.example.com"); 404 OHOS::Url::URL url("//asd", base); 405 napi_env env = (napi_env)engine_; 406 napi_value result = url.GetOnOrOff(env); 407 bool value = false; 408 napi_get_value_bool(env, result, &value); 409 ASSERT_TRUE(value); 410} 411 412HWTEST_F(NativeEngineTest, testUrlProtocol001, testing::ext::TestSize.Level0) 413{ 414 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 415 std::string output; 416 napi_env env = (napi_env)engine_; 417 DealNapiStrValue(env, url.GetScheme(env), output); 418 ASSERT_STREQ(output.c_str(), "http:"); 419} 420 421HWTEST_F(NativeEngineTest, testUrlProtocol002, testing::ext::TestSize.Level0) 422{ 423 OHOS::Url::URL url("ftp://username:password@host:8080/directory/file?query#fragment"); 424 std::string output; 425 napi_env env = (napi_env)engine_; 426 DealNapiStrValue(env, url.GetScheme(env), output); 427 ASSERT_STREQ(output.c_str(), "ftp:"); 428} 429 430HWTEST_F(NativeEngineTest, testUrlProtocol003, testing::ext::TestSize.Level0) 431{ 432 OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment"); 433 std::string output; 434 napi_env env = (napi_env)engine_; 435 DealNapiStrValue(env, url.GetScheme(env), output); 436 ASSERT_STREQ(output.c_str(), "https:"); 437} 438 439HWTEST_F(NativeEngineTest, testUrlSetScheme001, testing::ext::TestSize.Level0) 440{ 441 OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment"); 442 std::string output; 443 napi_env env = (napi_env)engine_; 444 DealNapiStrValue(env, url.GetScheme(env), output); 445 ASSERT_STREQ(output.c_str(), "https:"); 446 url.SetScheme("ftp:"); 447 DealNapiStrValue(env, url.GetScheme(env), output); 448 ASSERT_STREQ(output.c_str(), "ftp:"); 449} 450 451HWTEST_F(NativeEngineTest, testUrlSetScheme002, testing::ext::TestSize.Level0) 452{ 453 OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment"); 454 std::string output; 455 napi_env env = (napi_env)engine_; 456 DealNapiStrValue(env, url.GetScheme(env), output); 457 ASSERT_STREQ(output.c_str(), "https:"); 458 url.SetScheme("666"); 459 DealNapiStrValue(env, url.GetScheme(env), output); 460 ASSERT_STREQ(output.c_str(), "https:"); 461} 462 463HWTEST_F(NativeEngineTest, testUrlSetScheme003, testing::ext::TestSize.Level0) 464{ 465 OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment"); 466 std::string output; 467 napi_env env = (napi_env)engine_; 468 DealNapiStrValue(env, url.GetScheme(env), output); 469 ASSERT_STREQ(output.c_str(), "https:"); 470 url.SetScheme("-/+"); 471 DealNapiStrValue(env, url.GetScheme(env), output); 472 ASSERT_STREQ(output.c_str(), "https:"); 473} 474 475HWTEST_F(NativeEngineTest, testUrlSetScheme004, testing::ext::TestSize.Level0) 476{ 477 OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment"); 478 std::string output; 479 napi_env env = (napi_env)engine_; 480 DealNapiStrValue(env, url.GetScheme(env), output); 481 ASSERT_STREQ(output.c_str(), "https:"); 482 url.SetScheme("file"); 483 DealNapiStrValue(env, url.GetScheme(env), output); 484 ASSERT_STREQ(output.c_str(), "https:"); 485} 486 487HWTEST_F(NativeEngineTest, testUrlUsername001, testing::ext::TestSize.Level0) 488{ 489 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 490 std::string output; 491 napi_env env = (napi_env)engine_; 492 DealNapiStrValue(env, url.GetUsername(env), output); 493 ASSERT_STREQ(output.c_str(), "username"); 494} 495 496HWTEST_F(NativeEngineTest, testUrlUsername002, testing::ext::TestSize.Level0) 497{ 498 OHOS::Url::URL url("http://zhao:password@host:8080/directory/file?query#fragment"); 499 std::string output; 500 napi_env env = (napi_env)engine_; 501 DealNapiStrValue(env, url.GetUsername(env), output); 502 ASSERT_STREQ(output.c_str(), "zhao"); 503} 504 505HWTEST_F(NativeEngineTest, testUrlUsername003, testing::ext::TestSize.Level0) 506{ 507 OHOS::Url::URL url("http://skk:password@host:8080/directory/file?query#fragment"); 508 std::string output; 509 napi_env env = (napi_env)engine_; 510 DealNapiStrValue(env, url.GetUsername(env), output); 511 ASSERT_STREQ(output.c_str(), "skk"); 512} 513 514HWTEST_F(NativeEngineTest, testUrlSetUsername001, testing::ext::TestSize.Level0) 515{ 516 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 517 std::string output; 518 napi_env env = (napi_env)engine_; 519 DealNapiStrValue(env, url.GetUsername(env), output); 520 ASSERT_STREQ(output.c_str(), "username"); 521 url.SetUsername("666"); 522 DealNapiStrValue(env, url.GetUsername(env), output); 523 ASSERT_STREQ(output.c_str(), "666"); 524} 525 526HWTEST_F(NativeEngineTest, testUrlSetUsername002, testing::ext::TestSize.Level0) 527{ 528 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 529 std::string output; 530 napi_env env = (napi_env)engine_; 531 DealNapiStrValue(env, url.GetUsername(env), output); 532 ASSERT_STREQ(output.c_str(), "username"); 533 url.SetUsername(""); 534 DealNapiStrValue(env, url.GetUsername(env), output); 535 ASSERT_STREQ(output.c_str(), ""); 536} 537 538HWTEST_F(NativeEngineTest, testUrlPassword001, testing::ext::TestSize.Level0) 539{ 540 OHOS::Url::URL url("http://username:11@host:8080/directory/file?query#fragment"); 541 std::string output; 542 napi_env env = (napi_env)engine_; 543 DealNapiStrValue(env, url.GetPassword(env), output); 544 ASSERT_STREQ(output.c_str(), "11"); 545} 546 547HWTEST_F(NativeEngineTest, testUrlPassword002, testing::ext::TestSize.Level0) 548{ 549 OHOS::Url::URL url("http://username:23aa@host:8080/directory/file?query#fragment"); 550 std::string output; 551 napi_env env = (napi_env)engine_; 552 DealNapiStrValue(env, url.GetPassword(env), output); 553 ASSERT_STREQ(output.c_str(), "23aa"); 554} 555 556HWTEST_F(NativeEngineTest, testUrlPassword003, testing::ext::TestSize.Level0) 557{ 558 OHOS::Url::URL url("http://username@host:8080/directory/file?query#fragment"); 559 std::string output; 560 napi_env env = (napi_env)engine_; 561 DealNapiStrValue(env, url.GetPassword(env), output); 562 ASSERT_STREQ(output.c_str(), ""); 563} 564 565HWTEST_F(NativeEngineTest, testUrlSetPassword001, testing::ext::TestSize.Level0) 566{ 567 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 568 std::string output; 569 napi_env env = (napi_env)engine_; 570 DealNapiStrValue(env, url.GetPassword(env), output); 571 ASSERT_STREQ(output.c_str(), "password"); 572 url.SetPassword("666"); 573 DealNapiStrValue(env, url.GetPassword(env), output); 574 ASSERT_STREQ(output.c_str(), "666"); 575} 576 577HWTEST_F(NativeEngineTest, testUrlSetPassword002, testing::ext::TestSize.Level0) 578{ 579 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 580 std::string output; 581 napi_env env = (napi_env)engine_; 582 DealNapiStrValue(env, url.GetPassword(env), output); 583 ASSERT_STREQ(output.c_str(), "password"); 584 url.SetPassword(""); 585 DealNapiStrValue(env, url.GetPassword(env), output); 586 ASSERT_STREQ(output.c_str(), ""); 587} 588 589HWTEST_F(NativeEngineTest, testUrlHost001, testing::ext::TestSize.Level0) 590{ 591 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 592 std::string output; 593 napi_env env = (napi_env)engine_; 594 DealNapiStrValue(env, url.GetHost(env), output); 595 ASSERT_STREQ(output.c_str(), "host:8080"); 596} 597 598HWTEST_F(NativeEngineTest, testUrlHost002, testing::ext::TestSize.Level0) 599{ 600 OHOS::Url::URL url("http://username:password@hosthost/directory/file?query#fragment"); 601 std::string output; 602 napi_env env = (napi_env)engine_; 603 DealNapiStrValue(env, url.GetHost(env), output); 604 ASSERT_STREQ(output.c_str(), "hosthost"); 605} 606 607HWTEST_F(NativeEngineTest, testUrlHost003, testing::ext::TestSize.Level0) 608{ 609 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 610 std::string output; 611 napi_env env = (napi_env)engine_; 612 DealNapiStrValue(env, url.GetHost(env), output); 613 ASSERT_STREQ(output.c_str(), "host:199"); 614} 615 616HWTEST_F(NativeEngineTest, testUrlSetHost001, testing::ext::TestSize.Level0) 617{ 618 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 619 std::string output; 620 napi_env env = (napi_env)engine_; 621 DealNapiStrValue(env, url.GetHost(env), output); 622 ASSERT_STREQ(output.c_str(), "host:199"); 623 url.SetHost("0.0.0.0.0:199"); 624 DealNapiStrValue(env, url.GetHost(env), output); 625 ASSERT_STREQ(output.c_str(), "0.0.0.0.0:199"); 626} 627 628HWTEST_F(NativeEngineTest, testUrlSetHost002, testing::ext::TestSize.Level0) 629{ 630 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 631 std::string output; 632 napi_env env = (napi_env)engine_; 633 DealNapiStrValue(env, url.GetHost(env), output); 634 ASSERT_STREQ(output.c_str(), "host:199"); 635 url.SetHost(""); 636 DealNapiStrValue(env, url.GetHost(env), output); 637 ASSERT_STREQ(output.c_str(), "host:199"); 638} 639 640HWTEST_F(NativeEngineTest, testUrlSetHost003, testing::ext::TestSize.Level0) 641{ 642 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 643 std::string output; 644 napi_env env = (napi_env)engine_; 645 DealNapiStrValue(env, url.GetHost(env), output); 646 ASSERT_STREQ(output.c_str(), "host:199"); 647 url.SetHost("/"); 648 DealNapiStrValue(env, url.GetHost(env), output); 649 ASSERT_STREQ(output.c_str(), "host:199"); 650} 651 652HWTEST_F(NativeEngineTest, testUrlSetHost004, testing::ext::TestSize.Level0) 653{ 654 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 655 std::string output; 656 napi_env env = (napi_env)engine_; 657 DealNapiStrValue(env, url.GetHost(env), output); 658 ASSERT_STREQ(output.c_str(), "host:199"); 659 url.SetHost("asdzxc:54/"); 660 napi_value result = url.GetOnOrOff(env); 661 bool value = false; 662 napi_get_value_bool(env, result, &value); 663 ASSERT_TRUE(value); 664} 665 666HWTEST_F(NativeEngineTest, testUrlSetHref001, testing::ext::TestSize.Level0) 667{ 668 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 669 std::string output; 670 napi_env env = (napi_env)engine_; 671 DealNapiStrValue(env, url.GetHost(env), output); 672 ASSERT_STREQ(output.c_str(), "host:199"); 673 url.SetHref("http:example.com"); 674 DealNapiStrValue(env, url.GetHost(env), output); 675 ASSERT_STREQ(output.c_str(), "example.com"); 676} 677 678HWTEST_F(NativeEngineTest, testUrlSetHref002, testing::ext::TestSize.Level0) 679{ 680 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 681 std::string output; 682 napi_env env = (napi_env)engine_; 683 DealNapiStrValue(env, url.GetHost(env), output); 684 ASSERT_STREQ(output.c_str(), "host:199"); 685 url.SetHref(" http:example.com"); 686 DealNapiStrValue(env, url.GetHost(env), output); 687 ASSERT_STREQ(output.c_str(), "example.com"); 688} 689 690HWTEST_F(NativeEngineTest, testUrlHostname001, testing::ext::TestSize.Level0) 691{ 692 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 693 std::string output; 694 napi_env env = (napi_env)engine_; 695 DealNapiStrValue(env, url.GetHostname(env), output); 696 ASSERT_STREQ(output.c_str(), "host"); 697} 698 699HWTEST_F(NativeEngineTest, testUrlHostname002, testing::ext::TestSize.Level0) 700{ 701 OHOS::Url::URL url("http://username:password@host123:8080/directory/file?query#fragment"); 702 std::string output; 703 napi_env env = (napi_env)engine_; 704 DealNapiStrValue(env, url.GetHostname(env), output); 705 ASSERT_STREQ(output.c_str(), "host123"); 706} 707 708HWTEST_F(NativeEngineTest, testUrlHostname003, testing::ext::TestSize.Level0) 709{ 710 OHOS::Url::URL url("http://username:password@885ssa:8080/directory/file?query#fragment"); 711 std::string output; 712 napi_env env = (napi_env)engine_; 713 DealNapiStrValue(env, url.GetHostname(env), output); 714 ASSERT_STREQ(output.c_str(), "885ssa"); 715} 716 717HWTEST_F(NativeEngineTest, testUrlPort001, testing::ext::TestSize.Level0) 718{ 719 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 720 std::string output; 721 napi_env env = (napi_env)engine_; 722 DealNapiStrValue(env, url.GetPort(env), output); 723 ASSERT_STREQ(output.c_str(), "8080"); 724} 725 726HWTEST_F(NativeEngineTest, testUrlPort002, testing::ext::TestSize.Level0) 727{ 728 OHOS::Url::URL url("http://username:password@host:100/directory/file?query#fragment"); 729 std::string output; 730 napi_env env = (napi_env)engine_; 731 DealNapiStrValue(env, url.GetPort(env), output); 732 ASSERT_STREQ(output.c_str(), "100"); 733} 734 735 736HWTEST_F(NativeEngineTest, testUrlPort003, testing::ext::TestSize.Level0) 737{ 738 OHOS::Url::URL url("http://username:password@host/directory/file?query#fragment"); 739 std::string output; 740 napi_env env = (napi_env)engine_; 741 DealNapiStrValue(env, url.GetPort(env), output); 742 ASSERT_STREQ(output.c_str(), ""); 743} 744 745HWTEST_F(NativeEngineTest, testUrlPort004, testing::ext::TestSize.Level0) 746{ 747 OHOS::Url::URL url("http://username:password@host:655656/directory/file?query#fragment"); 748 napi_env env = (napi_env)engine_; 749 napi_value result = url.GetOnOrOff(env); 750 bool value = false; 751 napi_get_value_bool(env, result, &value); 752 ASSERT_FALSE(value); 753} 754 755HWTEST_F(NativeEngineTest, testUrlPort005, testing::ext::TestSize.Level0) 756{ 757 OHOS::Url::URL url("http://username:password@host:6c3/directory/file?query#fragment"); 758 napi_env env = (napi_env)engine_; 759 napi_value result = url.GetOnOrOff(env); 760 bool value = false; 761 napi_get_value_bool(env, result, &value); 762 ASSERT_FALSE(value); 763} 764 765HWTEST_F(NativeEngineTest, testUrlSetPort001, testing::ext::TestSize.Level0) 766{ 767 OHOS::Url::URL url("http://username:password@host:100/directory/file?query#fragment"); 768 std::string output; 769 napi_env env = (napi_env)engine_; 770 DealNapiStrValue(env, url.GetPort(env), output); 771 ASSERT_STREQ(output.c_str(), "100"); 772 url.SetPort("600?"); 773 DealNapiStrValue(env, url.GetPort(env), output); 774 ASSERT_STREQ(output.c_str(), "600"); 775} 776 777HWTEST_F(NativeEngineTest, testUrlPathname001, testing::ext::TestSize.Level0) 778{ 779 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment"); 780 std::string output; 781 napi_env env = (napi_env)engine_; 782 DealNapiStrValue(env, url.GetPath(env), output); 783 ASSERT_STREQ(output.c_str(), "/directory/file"); 784} 785 786HWTEST_F(NativeEngineTest, testUrlPathname002, testing::ext::TestSize.Level0) 787{ 788 OHOS::Url::URL url("http://username:password@host:8080/directory?query#fragment"); 789 std::string output; 790 napi_env env = (napi_env)engine_; 791 DealNapiStrValue(env, url.GetPath(env), output); 792 ASSERT_STREQ(output.c_str(), "/directory"); 793} 794 795HWTEST_F(NativeEngineTest, testUrlPathname003, testing::ext::TestSize.Level0) 796{ 797 OHOS::Url::URL url("http2://username:password@host:8080?query#fragment"); 798 std::string output; 799 napi_env env = (napi_env)engine_; 800 DealNapiStrValue(env, url.GetPath(env), output); 801 ASSERT_STREQ(output.c_str(), ""); 802} 803 804HWTEST_F(NativeEngineTest, testUrlPathname004, testing::ext::TestSize.Level0) 805{ 806 OHOS::Url::URL url("http://username:password@host:8080?query#fragment"); 807 napi_env env = (napi_env)engine_; 808 napi_value result = url.GetOnOrOff(env); 809 bool value = false; 810 napi_get_value_bool(env, result, &value); 811 ASSERT_TRUE(value); 812} 813 814HWTEST_F(NativeEngineTest, testUrlSetPath001, testing::ext::TestSize.Level0) 815{ 816 OHOS::Url::URL url("http://username:password@host:8080?query#fragment"); 817 std::string output; 818 napi_env env = (napi_env)engine_; 819 DealNapiStrValue(env, url.GetPath(env), output); 820 ASSERT_STREQ(output.c_str(), "/"); 821 url.SetPath("\\D:"); 822 DealNapiStrValue(env, url.GetPath(env), output); 823 ASSERT_STREQ(output.c_str(), "/D:"); 824} 825 826HWTEST_F(NativeEngineTest, testUrlSetPath002, testing::ext::TestSize.Level0) 827{ 828 OHOS::Url::URL url("http://username:password@host:8080?query#fragment"); 829 std::string output; 830 napi_env env = (napi_env)engine_; 831 DealNapiStrValue(env, url.GetPath(env), output); 832 ASSERT_STREQ(output.c_str(), "/"); 833 url.SetPath(":\\D:"); 834 DealNapiStrValue(env, url.GetPath(env), output); 835 ASSERT_STREQ(output.c_str(), "/:/D:"); 836} 837 838HWTEST_F(NativeEngineTest, testUrlSetPath003, testing::ext::TestSize.Level0) 839{ 840 OHOS::Url::URL url("http://username:password@host:8080?query#fragment"); 841 std::string output; 842 napi_env env = (napi_env)engine_; 843 DealNapiStrValue(env, url.GetPath(env), output); 844 ASSERT_STREQ(output.c_str(), "/"); 845 url.SetPath("::"); 846 DealNapiStrValue(env, url.GetPath(env), output); 847 ASSERT_STREQ(output.c_str(), "/::"); 848} 849 850HWTEST_F(NativeEngineTest, testUrlSetPath004, testing::ext::TestSize.Level0) 851{ 852 OHOS::Url::URL url("http://username:password@host:8080?query#fragment"); 853 std::string output; 854 napi_env env = (napi_env)engine_; 855 DealNapiStrValue(env, url.GetPath(env), output); 856 ASSERT_STREQ(output.c_str(), "/"); 857 url.SetPath(""); 858 DealNapiStrValue(env, url.GetPath(env), output); 859 ASSERT_STREQ(output.c_str(), "/"); 860} 861 862HWTEST_F(NativeEngineTest, testUrlSetPath005, testing::ext::TestSize.Level0) 863{ 864 OHOS::Url::URL url("file://hostsasf"); 865 std::string output; 866 napi_env env = (napi_env)engine_; 867 url.SetPath("/askdj"); 868 DealNapiStrValue(env, url.GetPath(env), output); 869 ASSERT_STREQ(output.c_str(), "/askdj"); 870} 871 872HWTEST_F(NativeEngineTest, testUrlSearch001, testing::ext::TestSize.Level0) 873{ 874 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=qqqq#fragment"); 875 std::string output; 876 napi_env env = (napi_env)engine_; 877 DealNapiStrValue(env, url.GetSearch(env), output); 878 ASSERT_STREQ(output.c_str(), "?query=qqqq"); 879} 880 881HWTEST_F(NativeEngineTest, testUrlSearch002, testing::ext::TestSize.Level0) 882{ 883 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=qqqq&ll=pp#fragment"); 884 std::string output; 885 napi_env env = (napi_env)engine_; 886 DealNapiStrValue(env, url.GetSearch(env), output); 887 ASSERT_STREQ(output.c_str(), "?query=qqqq&ll=pp"); 888} 889 890HWTEST_F(NativeEngineTest, testUrlSearch003, testing::ext::TestSize.Level0) 891{ 892 OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment"); 893 std::string output; 894 napi_env env = (napi_env)engine_; 895 DealNapiStrValue(env, url.GetSearch(env), output); 896 ASSERT_STREQ(output.c_str(), "?ppp9875=77"); 897} 898 899HWTEST_F(NativeEngineTest, testUrlSetSearch001, testing::ext::TestSize.Level0) 900{ 901 OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment"); 902 std::string output; 903 napi_env env = (napi_env)engine_; 904 DealNapiStrValue(env, url.GetSearch(env), output); 905 ASSERT_STREQ(output.c_str(), "?ppp9875=77"); 906 url.SetSearch(""); 907 DealNapiStrValue(env, url.GetSearch(env), output); 908 ASSERT_STREQ(output.c_str(), ""); 909} 910 911HWTEST_F(NativeEngineTest, testUrlSetSearch002, testing::ext::TestSize.Level0) 912{ 913 OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment"); 914 std::string output; 915 napi_env env = (napi_env)engine_; 916 DealNapiStrValue(env, url.GetSearch(env), output); 917 ASSERT_STREQ(output.c_str(), "?ppp9875=77"); 918 url.SetSearch("?444=555"); 919 DealNapiStrValue(env, url.GetSearch(env), output); 920 ASSERT_STREQ(output.c_str(), "?444=555"); 921} 922 923HWTEST_F(NativeEngineTest, testUrlSetSearch003, testing::ext::TestSize.Level0) 924{ 925 OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment"); 926 std::string output; 927 napi_env env = (napi_env)engine_; 928 DealNapiStrValue(env, url.GetSearch(env), output); 929 ASSERT_STREQ(output.c_str(), "?ppp9875=77"); 930 url.SetSearch("444=555"); 931 DealNapiStrValue(env, url.GetSearch(env), output); 932 ASSERT_STREQ(output.c_str(), "?444=555"); 933} 934 935HWTEST_F(NativeEngineTest, testUrlSetSearch004, testing::ext::TestSize.Level0) 936{ 937 OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment"); 938 std::string output; 939 napi_env env = (napi_env)engine_; 940 DealNapiStrValue(env, url.GetSearch(env), output); 941 ASSERT_STREQ(output.c_str(), "?ppp9875=77"); 942 url.SetSearch("?##44=55"); 943 DealNapiStrValue(env, url.GetSearch(env), output); 944 ASSERT_STREQ(output.c_str(), "?%23%2344=55"); 945} 946 947HWTEST_F(NativeEngineTest, testUrlGetFragment001, testing::ext::TestSize.Level0) 948{ 949 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#fragment"); 950 std::string output; 951 napi_env env = (napi_env)engine_; 952 DealNapiStrValue(env, url.GetFragment(env), output); 953 ASSERT_STREQ(output.c_str(), "#fragment"); 954} 955 956HWTEST_F(NativeEngineTest, testUrlGetFragment002, testing::ext::TestSize.Level0) 957{ 958 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#fragment"); 959 std::string output; 960 napi_env env = (napi_env)engine_; 961 DealNapiStrValue(env, url.GetFragment(env), output); 962 ASSERT_STREQ(output.c_str(), "#fragment"); 963} 964 965HWTEST_F(NativeEngineTest, testUrlGetFragment003, testing::ext::TestSize.Level0) 966{ 967 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456"); 968 std::string output; 969 napi_env env = (napi_env)engine_; 970 DealNapiStrValue(env, url.GetFragment(env), output); 971 ASSERT_STREQ(output.c_str(), "#123456"); 972} 973 974HWTEST_F(NativeEngineTest, testUrlSetFragment001, testing::ext::TestSize.Level0) 975{ 976 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456"); 977 std::string output; 978 napi_env env = (napi_env)engine_; 979 DealNapiStrValue(env, url.GetFragment(env), output); 980 ASSERT_STREQ(output.c_str(), "#123456"); 981 url.SetFragment(""); 982 DealNapiStrValue(env, url.GetFragment(env), output); 983 ASSERT_STREQ(output.c_str(), ""); 984} 985 986HWTEST_F(NativeEngineTest, testUrlSetFragment002, testing::ext::TestSize.Level0) 987{ 988 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456"); 989 std::string output; 990 napi_env env = (napi_env)engine_; 991 DealNapiStrValue(env, url.GetFragment(env), output); 992 ASSERT_STREQ(output.c_str(), "#123456"); 993 url.SetFragment("#445566"); 994 DealNapiStrValue(env, url.GetFragment(env), output); 995 ASSERT_STREQ(output.c_str(), "#445566"); 996} 997 998HWTEST_F(NativeEngineTest, testUrlSetFragment003, testing::ext::TestSize.Level0) 999{ 1000 OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456"); 1001 std::string output; 1002 napi_env env = (napi_env)engine_; 1003 DealNapiStrValue(env, url.GetFragment(env), output); 1004 ASSERT_STREQ(output.c_str(), "#123456"); 1005 url.SetFragment("445566"); 1006 DealNapiStrValue(env, url.GetFragment(env), output); 1007 ASSERT_STREQ(output.c_str(), "#445566"); 1008} 1009 1010HWTEST_F(NativeEngineTest, testUrlIPV6001, testing::ext::TestSize.Level0) 1011{ 1012 OHOS::Url::URL url("http://[1080:0:0:0:8:800:200C:417A]/index.html"); 1013 napi_env env = (napi_env)engine_; 1014 napi_value result = url.GetIsIpv6(env); 1015 bool value = false; 1016 napi_get_value_bool(env, result, &value); 1017 ASSERT_TRUE(value); 1018} 1019 1020HWTEST_F(NativeEngineTest, testUrlIPV6002, testing::ext::TestSize.Level0) 1021{ 1022 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 1023 napi_env env = (napi_env)engine_; 1024 napi_value result = url.GetIsIpv6(env); 1025 bool value = false; 1026 napi_get_value_bool(env, result, &value); 1027 ASSERT_FALSE(value); 1028} 1029 1030HWTEST_F(NativeEngineTest, testUrlIPV6003, testing::ext::TestSize.Level0) 1031{ 1032 OHOS::Url::URL url("http://[1080:0:0:0:8:800:200C.417A]/index.html"); 1033 napi_env env = (napi_env)engine_; 1034 napi_value result = url.GetIsIpv6(env); 1035 bool value = false; 1036 napi_get_value_bool(env, result, &value); 1037 ASSERT_FALSE(value); 1038} 1039 1040HWTEST_F(NativeEngineTest, testUrlGetOnOrOff001, testing::ext::TestSize.Level0) 1041{ 1042 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 1043 napi_env env = (napi_env)engine_; 1044 napi_value result = url.GetOnOrOff(env); 1045 bool value = false; 1046 napi_get_value_bool(env, result, &value); 1047 ASSERT_TRUE(value); 1048} 1049 1050HWTEST_F(NativeEngineTest, testUrlGetOnOrOff002, testing::ext::TestSize.Level0) 1051{ 1052 OHOS::Url::URL url("http://192.168.259.551:80/index.html"); 1053 napi_env env = (napi_env)engine_; 1054 napi_value result = url.GetOnOrOff(env); 1055 bool value = false; 1056 napi_get_value_bool(env, result, &value); 1057 ASSERT_FALSE(value); 1058} 1059 1060HWTEST_F(NativeEngineTest, testUrlSetHostname001, testing::ext::TestSize.Level0) 1061{ 1062 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 1063 napi_env env = (napi_env)engine_; 1064 std::string output; 1065 std::string value = "host"; 1066 url.SetHostname(value); 1067 DealNapiStrValue(env, url.GetHostname(env), output); 1068 ASSERT_STREQ(output.c_str(), "host"); 1069} 1070 1071HWTEST_F(NativeEngineTest, testUrlSetHostname002, testing::ext::TestSize.Level0) 1072{ 1073 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 1074 napi_env env = (napi_env)engine_; 1075 std::string output; 1076 std::string value = ""; 1077 url.SetHostname(value); 1078 DealNapiStrValue(env, url.GetHostname(env), output); 1079 ASSERT_STREQ(output.c_str(), "255.255.255.1"); 1080} 1081 1082HWTEST_F(NativeEngineTest, testUrlSetHostname003, testing::ext::TestSize.Level0) 1083{ 1084 OHOS::Url::URL url("file:///www.example.com"); 1085 napi_env env = (napi_env)engine_; 1086 std::string value = "localhost/"; 1087 url.SetHostname(value); 1088 napi_value result = url.GetOnOrOff(env); 1089 bool value1 = false; 1090 napi_get_value_bool(env, result, &value1); 1091 ASSERT_TRUE(value1); 1092} 1093 1094HWTEST_F(NativeEngineTest, testUrlSearchParams001, testing::ext::TestSize.Level0) 1095{ 1096 OHOS::Url::URL url("http://username:password@host:8080/directory/file?foo=1&bar=2"); 1097 std::string output; 1098 napi_env env = (napi_env)engine_; 1099 DealNapiStrValue(env, url.GetSearch(env), output); 1100 ASSERT_STREQ(output.c_str(), "?foo=1&bar=2"); 1101} 1102 1103HWTEST_F(NativeEngineTest, testUrlSearchParams002, testing::ext::TestSize.Level0) 1104{ 1105 OHOS::Url::URL url("https://example.com?d=value1&c=value2&b=大&4=key4"); 1106 std::string output; 1107 napi_env env = (napi_env)engine_; 1108 DealNapiStrValue(env, url.GetSearch(env), output); 1109 ASSERT_STREQ(output.c_str(), "?d=value1&c=value2&b=大&4=key4"); 1110} 1111 1112HWTEST_F(NativeEngineTest, testUrlSearchParams003, testing::ext::TestSize.Level0) 1113{ 1114 OHOS::Url::URL url("http://username:password@host:8080/directory/file?你好=china#qwer=da"); 1115 std::string output; 1116 napi_env env = (napi_env)engine_; 1117 DealNapiStrValue(env, url.GetSearch(env), output); 1118 ASSERT_STREQ(output.c_str(), "?你好=china"); 1119} 1120 1121HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend001, testing::ext::TestSize.Level0) 1122{ 1123 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1124 std::string output; 1125 napi_env env = (napi_env)engine_; 1126 napi_value input1 = StrToNapiValue(env, "ma"); 1127 napi_value input2 = StrToNapiValue(env, "jk"); 1128 params.Append(env, input1, input2); 1129 napi_value tempValue = params.GetArray(env); 1130 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1131 DealNapiStrValue(env, ToString(env, paramsString), output); 1132 ASSERT_STREQ(output.c_str(), "ma=jk"); 1133} 1134 1135HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend002, testing::ext::TestSize.Level0) 1136{ 1137 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1138 std::string output; 1139 napi_env env = (napi_env)engine_; 1140 napi_value input1 = StrToNapiValue(env, "ma 大"); 1141 napi_value input2 = StrToNapiValue(env, "jk￥"); 1142 params.Append(env, input1, input2); 1143 napi_value tempValue = params.GetArray(env); 1144 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1145 DealNapiStrValue(env, ToString(env, paramsString), output); 1146 ASSERT_STREQ(output.c_str(), "ma+%E5%A4%A7=jk%EF%BF%A5"); 1147} 1148 1149HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend003, testing::ext::TestSize.Level0) 1150{ 1151 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1152 std::string output; 1153 napi_env env = (napi_env)engine_; 1154 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1155 napi_value input2 = StrToNapiValue(env, "jk"); 1156 params.Append(env, input1, input2); 1157 napi_value tempValue = params.GetArray(env); 1158 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1159 DealNapiStrValue(env, ToString(env, paramsString), output); 1160 ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk"); 1161} 1162 1163HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend004, testing::ext::TestSize.Level0) 1164{ 1165 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1166 std::string output; 1167 napi_env env = (napi_env)engine_; 1168 napi_value result = nullptr; 1169 napi_get_undefined(env, &result); 1170 napi_value input2 = StrToNapiValue(env, "jk"); 1171 params.Append(env, result, input2); 1172 DealNapiStrValue(env, params.Get(env, input2), output); 1173 ASSERT_STREQ(output.c_str(), ""); 1174} 1175 1176HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend005, testing::ext::TestSize.Level0) 1177{ 1178 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1179 std::string output; 1180 napi_env env = (napi_env)engine_; 1181 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1182 napi_value result = nullptr; 1183 napi_get_undefined(env, &result); 1184 params.Append(env, input1, result); 1185 DealNapiStrValue(env, params.Get(env, input1), output); 1186 ASSERT_STREQ(output.c_str(), ""); 1187} 1188 1189HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete001, testing::ext::TestSize.Level0) 1190{ 1191 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1192 std::string output; 1193 napi_env env = (napi_env)engine_; 1194 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1195 napi_value input2 = StrToNapiValue(env, "jk"); 1196 params.Append(env, input1, input2); 1197 params.Delete(env, input1); 1198 napi_value tempValue = params.GetArray(env); 1199 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1200 DealNapiStrValue(env, ToString(env, paramsString), output); 1201 ASSERT_STREQ(output.c_str(), ""); 1202} 1203 1204HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete002, testing::ext::TestSize.Level0) 1205{ 1206 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1207 std::string output; 1208 napi_env env = (napi_env)engine_; 1209 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1210 napi_value input2 = StrToNapiValue(env, "jk"); 1211 params.Append(env, input1, input2); 1212 napi_value input3 = StrToNapiValue(env, "ma"); 1213 napi_value input4 = StrToNapiValue(env, "jk"); 1214 params.Append(env, input3, input4); 1215 params.Delete(env, input1); 1216 napi_value tempValue = params.GetArray(env); 1217 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1218 DealNapiStrValue(env, ToString(env, paramsString), output); 1219 ASSERT_STREQ(output.c_str(), "ma=jk"); 1220} 1221 1222HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete003, testing::ext::TestSize.Level0) 1223{ 1224 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1225 std::string output; 1226 napi_env env = (napi_env)engine_; 1227 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1228 napi_value input2 = StrToNapiValue(env, "jk"); 1229 params.Append(env, input1, input2); 1230 napi_value input3 = StrToNapiValue(env, "ma"); 1231 napi_value input4 = StrToNapiValue(env, "jk"); 1232 params.Append(env, input3, input4); 1233 params.Delete(env, input1); 1234 params.Delete(env, input3); 1235 napi_value tempValue = params.GetArray(env); 1236 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1237 DealNapiStrValue(env, ToString(env, paramsString), output); 1238 ASSERT_STREQ(output.c_str(), ""); 1239} 1240 1241HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete004, testing::ext::TestSize.Level0) 1242{ 1243 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1244 std::string output; 1245 napi_env env = (napi_env)engine_; 1246 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1247 napi_value input2 = StrToNapiValue(env, "jk"); 1248 params.Append(env, input1, input2); 1249 napi_value input3 = StrToNapiValue(env, "ma"); 1250 napi_value input4 = StrToNapiValue(env, "jk"); 1251 params.Append(env, input3, input4); 1252 napi_value result = nullptr; 1253 napi_get_undefined(env, &result); 1254 params.Delete(env, result); 1255 DealNapiStrValue(env, params.Get(env, input3), output); 1256 ASSERT_STREQ(output.c_str(), "jk"); 1257} 1258 1259HWTEST_F(NativeEngineTest, testUrlSearchParamsGet001, testing::ext::TestSize.Level0) 1260{ 1261 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1262 std::string output; 1263 napi_env env = (napi_env)engine_; 1264 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1265 napi_value input2 = StrToNapiValue(env, "jk"); 1266 params.Append(env, input1, input2); 1267 DealNapiStrValue(env, params.Get(env, input1), output); 1268 ASSERT_STREQ(output.c_str(), "jk"); 1269} 1270 1271HWTEST_F(NativeEngineTest, testUrlSearchParamsGet002, testing::ext::TestSize.Level0) 1272{ 1273 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1274 std::string output; 1275 napi_env env = (napi_env)engine_; 1276 napi_value input1 = StrToNapiValue(env, "jk"); 1277 DealNapiStrValue(env, params.Get(env, input1), output); 1278 ASSERT_STREQ(output.c_str(), ""); 1279} 1280 1281HWTEST_F(NativeEngineTest, testUrlSearchParamsGet003, testing::ext::TestSize.Level0) 1282{ 1283 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1284 std::string output; 1285 napi_env env = (napi_env)engine_; 1286 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1287 napi_value input2 = StrToNapiValue(env, "jk"); 1288 params.Append(env, input1, input2); 1289 DealNapiStrValue(env, params.Get(env, input1), output); 1290 ASSERT_STREQ(output.c_str(), "jk"); 1291} 1292 1293HWTEST_F(NativeEngineTest, testUrlSearchParamsGet004, testing::ext::TestSize.Level0) 1294{ 1295 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1296 std::string output; 1297 napi_env env = (napi_env)engine_; 1298 napi_value input1 = StrToNapiValue(env, "hello, \U0001F600 world!"); 1299 DealNapiStrValue(env, params.Get(env, input1), output); 1300 ASSERT_STREQ(output.c_str(), ""); 1301} 1302 1303HWTEST_F(NativeEngineTest, testUrlSearchParamsGet005, testing::ext::TestSize.Level0) 1304{ 1305 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1306 std::string output; 1307 napi_env env = (napi_env)engine_; 1308 napi_value result = nullptr; 1309 napi_get_undefined(env, &result); 1310 DealNapiStrValue(env, params.Get(env, result), output); 1311 ASSERT_STREQ(output.c_str(), ""); 1312} 1313 1314HWTEST_F(NativeEngineTest, testUrlSearchParamsGet006, testing::ext::TestSize.Level0) 1315{ 1316 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1317 std::string output; 1318 napi_env env = (napi_env)engine_; 1319 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1320 napi_value input2 = StrToNapiValue(env, "jk"); 1321 napi_value input3 = StrToNapiValue(env, "asd"); 1322 params.Append(env, input1, input2); 1323 DealNapiStrValue(env, params.Get(env, input3), output); 1324 ASSERT_STREQ(output.c_str(), ""); 1325} 1326 1327HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll001, testing::ext::TestSize.Level0) 1328{ 1329 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1330 std::string output; 1331 napi_env env = (napi_env)engine_; 1332 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1333 napi_value input2 = StrToNapiValue(env, "jk"); 1334 params.Append(env, input1, input2); 1335 napi_value input3 = StrToNapiValue(env, "jk"); 1336 DealNapiStrValue(env, params.GetAll(env, input3), output); 1337 ASSERT_STREQ(output.c_str(), ""); 1338} 1339 1340HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll002, testing::ext::TestSize.Level0) 1341{ 1342 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1343 std::string output; 1344 napi_env env = (napi_env)engine_; 1345 napi_value input1 = StrToNapiValue(env, "ma"); 1346 napi_value input2 = StrToNapiValue(env, "jk"); 1347 params.Append(env, input1, input2); 1348 napi_value input3 = StrToNapiValue(env, "jk1"); 1349 DealNapiStrValue(env, params.GetAll(env, input3), output); 1350 ASSERT_STREQ(output.c_str(), ""); 1351} 1352 1353HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll003, testing::ext::TestSize.Level0) 1354{ 1355 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1356 std::string output; 1357 napi_env env = (napi_env)engine_; 1358 napi_value input1 = StrToNapiValue(env, "#[%@]"); 1359 napi_value input2 = StrToNapiValue(env, "jk"); 1360 params.Append(env, input1, input2); 1361 napi_value input3 = StrToNapiValue(env, "ma1"); 1362 napi_value input4 = StrToNapiValue(env, "jk1"); 1363 params.Append(env, input3, input4); 1364 napi_value input5 = StrToNapiValue(env, "jk2"); 1365 DealNapiStrValue(env, params.GetAll(env, input5), output); 1366 ASSERT_STREQ(output.c_str(), ""); 1367} 1368 1369HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll004, testing::ext::TestSize.Level0) 1370{ 1371 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1372 std::string output; 1373 napi_env env = (napi_env)engine_; 1374 napi_value result = nullptr; 1375 napi_get_undefined(env, &result); 1376 DealNapiStrValue(env, params.GetAll(env, result), output); 1377 ASSERT_STREQ(output.c_str(), ""); 1378} 1379 1380HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll005, testing::ext::TestSize.Level0) 1381{ 1382 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1383 std::string output; 1384 napi_env env = (napi_env)engine_; 1385 napi_value input1 = StrToNapiValue(env, "jk"); 1386 DealNapiStrValue(env, params.GetAll(env, input1), output); 1387 ASSERT_STREQ(output.c_str(), ""); 1388} 1389 1390HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll006, testing::ext::TestSize.Level0) 1391{ 1392 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1393 std::string output; 1394 napi_env env = (napi_env)engine_; 1395 napi_value input1 = StrToNapiValue(env, "ma"); 1396 napi_value input2 = StrToNapiValue(env, "jk"); 1397 params.Append(env, input1, input2); 1398 napi_value input3 = StrToNapiValue(env, "ma"); 1399 DealNapiStrValue(env, params.GetAll(env, input3), output); 1400 ASSERT_STREQ(output.c_str(), ""); 1401} 1402 1403HWTEST_F(NativeEngineTest, testUrlSearchParamsToUSVString001, testing::ext::TestSize.Level0) 1404{ 1405 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1406 std::string output; 1407 napi_env env = (napi_env)engine_; 1408 napi_value input1 = StrToNapiValue(env, "你好"); 1409 napi_value input2 = StrToNapiValue(env, "안녕하세요"); 1410 params.Append(env, input1, input2); 1411 napi_value input3 = StrToNapiValue(env, "[saa]"); 1412 napi_value input4 = StrToNapiValue(env, "{aas}"); 1413 params.Append(env, input3, input4); 1414 napi_value input5 = StrToNapiValue(env, "你好"); 1415 DealNapiStrValue(env, params.Get(env, input5), output); 1416 ASSERT_STREQ(output.c_str(), "안녕하세요"); 1417} 1418 1419HWTEST_F(NativeEngineTest, testUrlSearchParamsHas001, testing::ext::TestSize.Level0) 1420{ 1421 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1422 std::string output; 1423 napi_env env = (napi_env)engine_; 1424 napi_value input1 = StrToNapiValue(env, "ma"); 1425 DealNapiStrValue(env, params.IsHas(env, input1), output); 1426 ASSERT_STREQ(output.c_str(), ""); 1427} 1428 1429HWTEST_F(NativeEngineTest, testUrlSearchParamsHas002, testing::ext::TestSize.Level0) 1430{ 1431 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1432 std::string output; 1433 napi_env env = (napi_env)engine_; 1434 napi_value input1 = StrToNapiValue(env, "ma"); 1435 napi_value input2 = StrToNapiValue(env, "jk"); 1436 params.Append(env, input1, input2); 1437 napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1438 napi_value input4 = StrToNapiValue(env, "jk1"); 1439 params.Append(env, input3, input4); 1440 DealNapiStrValue(env, params.IsHas(env, input1), output); 1441 ASSERT_STREQ(output.c_str(), ""); 1442} 1443 1444HWTEST_F(NativeEngineTest, testUrlSearchParamsHas003, testing::ext::TestSize.Level0) 1445{ 1446 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1447 std::string output; 1448 napi_env env = (napi_env)engine_; 1449 napi_value input1 = StrToNapiValue(env, "ma"); 1450 napi_value input2 = StrToNapiValue(env, "jk"); 1451 params.Append(env, input1, input2); 1452 napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1453 napi_value input4 = StrToNapiValue(env, "jk1"); 1454 params.Append(env, input3, input4); 1455 DealNapiStrValue(env, params.IsHas(env, input3), output); 1456 ASSERT_STREQ(output.c_str(), ""); 1457} 1458 1459HWTEST_F(NativeEngineTest, testUrlSearchParamsHas004, testing::ext::TestSize.Level0) 1460{ 1461 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1462 std::string output; 1463 napi_env env = (napi_env)engine_; 1464 napi_value input1 = StrToNapiValue(env, "ma"); 1465 napi_value input2 = StrToNapiValue(env, "jk"); 1466 params.Append(env, input1, input2); 1467 napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1468 napi_value input4 = StrToNapiValue(env, "jk1"); 1469 params.Append(env, input3, input4); 1470 napi_value result = nullptr; 1471 napi_get_undefined(env, &result); 1472 DealNapiStrValue(env, params.IsHas(env, result), output); 1473 ASSERT_STREQ(output.c_str(), ""); 1474} 1475 1476HWTEST_F(NativeEngineTest, testUrlSearchParamsSet001, testing::ext::TestSize.Level0) 1477{ 1478 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1479 std::string output; 1480 napi_env env = (napi_env)engine_; 1481 napi_value input1 = StrToNapiValue(env, "ma"); 1482 napi_value input2 = StrToNapiValue(env, "jk"); 1483 params.Append(env, input1, input2); 1484 napi_value input3 = StrToNapiValue(env, "aa"); 1485 params.Set(env, input1, input3); 1486 napi_value tempValue = params.GetArray(env); 1487 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1488 DealNapiStrValue(env, ToString(env, paramsString), output); 1489 ASSERT_STREQ(output.c_str(), "ma=aa"); 1490} 1491 1492HWTEST_F(NativeEngineTest, testUrlSearchParamsSet002, testing::ext::TestSize.Level0) 1493{ 1494 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1495 std::string output; 1496 napi_env env = (napi_env)engine_; 1497 napi_value input1 = StrToNapiValue(env, "ma1"); 1498 napi_value input2 = StrToNapiValue(env, "aa"); 1499 params.Append(env, input1, input2); 1500 params.Set(env, input1, input2); 1501 napi_value tempValue = params.GetArray(env); 1502 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1503 DealNapiStrValue(env, ToString(env, paramsString), output); 1504 ASSERT_STREQ(output.c_str(), "ma1=aa"); 1505} 1506 1507HWTEST_F(NativeEngineTest, testUrlSearchParamsSet003, testing::ext::TestSize.Level0) 1508{ 1509 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1510 std::string output; 1511 napi_env env = (napi_env)engine_; 1512 napi_value input1 = StrToNapiValue(env, "ma"); 1513 napi_value input2 = StrToNapiValue(env, "jk"); 1514 params.Append(env, input1, input2); 1515 napi_value input3 = StrToNapiValue(env, "ma1"); 1516 napi_value input4 = StrToNapiValue(env, "aa"); 1517 params.Set(env, input3, input4); 1518 napi_value tempValue = params.GetArray(env); 1519 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1520 DealNapiStrValue(env, ToString(env, paramsString), output); 1521 ASSERT_STREQ(output.c_str(), "ma=jk&ma1=aa"); 1522} 1523 1524HWTEST_F(NativeEngineTest, testUrlSearchParamsSet004, testing::ext::TestSize.Level0) 1525{ 1526 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1527 std::string output; 1528 napi_env env = (napi_env)engine_; 1529 napi_value input1 = StrToNapiValue(env, "ma1"); 1530 napi_value input2 = StrToNapiValue(env, "aa"); 1531 params.Append(env, input1, input2); 1532 napi_value result = nullptr; 1533 napi_get_undefined(env, &result); 1534 params.Set(env, result, input2); 1535 napi_value tempValue = params.GetArray(env); 1536 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1537 DealNapiStrValue(env, ToString(env, paramsString), output); 1538 ASSERT_STREQ(output.c_str(), "ma1=aa"); 1539} 1540 1541HWTEST_F(NativeEngineTest, testUrlSearchParamsSet005, testing::ext::TestSize.Level0) 1542{ 1543 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1544 std::string output; 1545 napi_env env = (napi_env)engine_; 1546 napi_value input1 = StrToNapiValue(env, "ma1"); 1547 napi_value input2 = StrToNapiValue(env, "aa"); 1548 params.Append(env, input1, input2); 1549 napi_value result = nullptr; 1550 napi_get_undefined(env, &result); 1551 params.Set(env, input1, result); 1552 napi_value tempValue = params.GetArray(env); 1553 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1554 DealNapiStrValue(env, ToString(env, paramsString), output); 1555 ASSERT_STREQ(output.c_str(), "ma1=aa"); 1556} 1557 1558 1559HWTEST_F(NativeEngineTest, testUrlSearchParamsSort001, testing::ext::TestSize.Level0) 1560{ 1561 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1562 std::string output; 1563 napi_env env = (napi_env)engine_; 1564 napi_value input1 = StrToNapiValue(env, "ma"); 1565 napi_value input2 = StrToNapiValue(env, "jk"); 1566 params.Append(env, input1, input2); 1567 napi_value input3 = StrToNapiValue(env, "a"); 1568 napi_value input4 = StrToNapiValue(env, "jk1"); 1569 params.Append(env, input3, input4); 1570 params.Sort(); 1571 napi_value tempValue = params.GetArray(env); 1572 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1573 DealNapiStrValue(env, ToString(env, paramsString), output); 1574 ASSERT_STREQ(output.c_str(), "a=jk1&ma=jk"); 1575} 1576 1577HWTEST_F(NativeEngineTest, testUrlSearchParamsSort002, testing::ext::TestSize.Level0) 1578{ 1579 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1580 std::string output; 1581 napi_env env = (napi_env)engine_; 1582 napi_value input1 = StrToNapiValue(env, "ma"); 1583 napi_value input2 = StrToNapiValue(env, "jk"); 1584 params.Append(env, input1, input2); 1585 napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1586 napi_value input4 = StrToNapiValue(env, "jk1"); 1587 params.Append(env, input3, input4); 1588 params.Sort(); 1589 napi_value tempValue = params.GetArray(env); 1590 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1591 DealNapiStrValue(env, ToString(env, paramsString), output); 1592 ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk1&ma=jk"); 1593} 1594 1595HWTEST_F(NativeEngineTest, testUrlSearchParamsSort003, testing::ext::TestSize.Level0) 1596{ 1597 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1598 std::string output; 1599 napi_env env = (napi_env)engine_; 1600 napi_value input1 = StrToNapiValue(env, "ma"); 1601 napi_value input2 = StrToNapiValue(env, "jk"); 1602 params.Append(env, input1, input2); 1603 napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1604 napi_value input4 = StrToNapiValue(env, "jk1"); 1605 params.Append(env, input3, input4); 1606 napi_value input5 = StrToNapiValue(env, "a"); 1607 napi_value input6 = StrToNapiValue(env, "jk2"); 1608 params.Append(env, input5, input6); 1609 params.Sort(); 1610 napi_value tempValue = params.GetArray(env); 1611 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1612 DealNapiStrValue(env, ToString(env, paramsString), output); 1613 ASSERT_STREQ(output.c_str(), "a=jk2&foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk1&ma=jk"); 1614} 1615 1616HWTEST_F(NativeEngineTest, testUrlSearchParamsToString001, testing::ext::TestSize.Level0) 1617{ 1618 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1619 std::string output; 1620 napi_env env = (napi_env)engine_; 1621 napi_value input1 = StrToNapiValue(env, "1 12"); 1622 napi_value input2 = StrToNapiValue(env, "jk"); 1623 params.Append(env, input1, input2); 1624 napi_value tempValue = params.GetArray(env); 1625 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1626 DealNapiStrValue(env, ToString(env, paramsString), output); 1627 ASSERT_STREQ(output.c_str(), "1+12=jk"); 1628} 1629 1630HWTEST_F(NativeEngineTest, testUrlSearchParamsToString002, testing::ext::TestSize.Level0) 1631{ 1632 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1633 std::string output; 1634 napi_env env = (napi_env)engine_; 1635 napi_value input1 = StrToNapiValue(env, "￥=)"); 1636 napi_value input2 = StrToNapiValue(env, "jk"); 1637 params.Append(env, input1, input2); 1638 napi_value tempValue = params.GetArray(env); 1639 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1640 DealNapiStrValue(env, ToString(env, paramsString), output); 1641 ASSERT_STREQ(output.c_str(), "%EF%BF%A5%3D%29=jk"); 1642} 1643 1644HWTEST_F(NativeEngineTest, testUrlSearchParamsToString003, testing::ext::TestSize.Level0) 1645{ 1646 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1647 std::string output; 1648 napi_env env = (napi_env)engine_; 1649 napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-="); 1650 napi_value input2 = StrToNapiValue(env, "jk"); 1651 params.Append(env, input1, input2); 1652 napi_value tempValue = params.GetArray(env); 1653 std::vector<std::string> paramsString = GetParamsStrig(env, tempValue); 1654 DealNapiStrValue(env, ToString(env, paramsString), output); 1655 ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk"); 1656} 1657 1658HWTEST_F(NativeEngineTest, testUrlSearchParams, testing::ext::TestSize.Level0) 1659{ 1660 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1661 std::string output; 1662 napi_env env = (napi_env)engine_; 1663 napi_value input1 = StrToNapiValue(env, "ma"); 1664 DealNapiStrValue(env, params.IsHas(env, input1), output); 1665 ASSERT_STREQ(output.c_str(), ""); 1666} 1667 1668HWTEST_F(NativeEngineTest, testUrlSearchParamsSetArray, testing::ext::TestSize.Level0) 1669{ 1670 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1671 std::string input1 = "jk"; 1672 std::string input2 = "ma"; 1673 napi_env env = (napi_env)engine_; 1674 std::vector<std::string> vec; 1675 vec.push_back(input1); 1676 vec.push_back(input2); 1677 params.SetArray(env, vec); 1678 napi_value result = params.GetArray(env); 1679 uint32_t length = 0; 1680 napi_value napiStr = nullptr; 1681 size_t arraySize = 0; 1682 napi_get_array_length(env, result, &length); 1683 std::string cstr1 = ""; 1684 for (size_t i = 0; i < length; i++) { 1685 napi_get_element(env, result, i, &napiStr); 1686 napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize); 1687 if (arraySize > 0) { 1688 napi_get_value_string_utf8(env, napiStr, cstr1.data(), arraySize + 1, &arraySize); 1689 } 1690 if (i == 0) { 1691 ASSERT_STREQ("jk", cstr1.data()); 1692 } else { 1693 ASSERT_STREQ(cstr1.data(), "ma"); 1694 } 1695 } 1696} 1697 1698HWTEST_F(NativeEngineTest, testUrlSearchParamsIterByKeys, testing::ext::TestSize.Level0) 1699{ 1700 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1701 std::string input1 = "jk"; 1702 std::string input2 = "ma"; 1703 napi_env env = (napi_env)engine_; 1704 std::vector<std::string> vec; 1705 vec.push_back(input1); 1706 vec.push_back(input2); 1707 params.SetArray(env, vec); 1708 napi_value result = params.IterByKeys(env); 1709 uint32_t length = 0; 1710 napi_value napiStr = nullptr; 1711 size_t arraySize = 0; 1712 napi_get_array_length(env, result, &length); 1713 std::string cstr = ""; 1714 for (size_t i = 0; i < length; i += 2) { 1715 napi_get_element(env, result, i, &napiStr); 1716 napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize); 1717 if (arraySize > 0) { 1718 napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize); 1719 } 1720 } 1721 ASSERT_STREQ(cstr.data(), "jk"); 1722} 1723 1724HWTEST_F(NativeEngineTest, testUrlSearchParamsIterByValues, testing::ext::TestSize.Level0) 1725{ 1726 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1727 std::string input1 = "jk"; 1728 std::string input2 = "ma"; 1729 napi_env env = (napi_env)engine_; 1730 std::vector<std::string> vec; 1731 vec.push_back(input1); 1732 vec.push_back(input2); 1733 params.SetArray(env, vec); 1734 napi_value result = params.IterByValues(env); 1735 uint32_t length = 0; 1736 napi_value napiStr = nullptr; 1737 size_t arraySize = 0; 1738 napi_get_array_length(env, result, &length); 1739 std::string cstr = ""; 1740 for (size_t i = 0; i < length; i++) { 1741 napi_get_element(env, result, i, &napiStr); 1742 napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize); 1743 if (arraySize > 0) { 1744 napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize); 1745 } 1746 } 1747 ASSERT_STREQ(cstr.data(), "ma"); 1748} 1749 1750HWTEST_F(NativeEngineTest, testUrlSearchParamsEntries001, testing::ext::TestSize.Level0) 1751{ 1752 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1753 napi_env env = (napi_env)engine_; 1754 napi_value input1 = StrToNapiValue(env, "ma"); 1755 napi_value input2 = StrToNapiValue(env, "jk"); 1756 params.Append(env, input1, input2); 1757 napi_value input3 = StrToNapiValue(env, "你好"); 1758 napi_value input4 = StrToNapiValue(env, "jk1"); 1759 params.Append(env, input3, input4); 1760 napi_value input5 = StrToNapiValue(env, "a"); 1761 napi_value input6 = StrToNapiValue(env, "jk2"); 1762 params.Append(env, input5, input6); 1763 napi_value result = params.Entries(env); 1764 uint32_t length = 0; 1765 napi_value napiStr = nullptr; 1766 size_t arraySize = 0; 1767 napi_get_array_length(env, result, &length); 1768 std::string cstr = ""; 1769 for (size_t i = 0; i < length; i++) { 1770 napi_get_element(env, result, i, &napiStr); 1771 napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize); 1772 if (arraySize > 0) { 1773 napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize); 1774 } 1775 } 1776 ASSERT_EQ(length, 3); 1777} 1778 1779HWTEST_F(NativeEngineTest, testUrlSearchParamsEntries002, testing::ext::TestSize.Level0) 1780{ 1781 OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams(); 1782 napi_env env = (napi_env)engine_; 1783 std::string output; 1784 params.Entries(env); 1785 napi_value input1 = StrToNapiValue(env, "ma"); 1786 DealNapiStrValue(env, params.Get(env, input1), output); 1787 ASSERT_STREQ(output.c_str(), ""); 1788} 1789 1790HWTEST_F(NativeEngineTest, testUrlutilities001, testing::ext::TestSize.Level0) 1791{ 1792 std::string inPut = ""; 1793 OHOS::Url::DecodeSpecialChars(inPut); 1794 inPut = "%1238"; 1795 OHOS::Url::DecodeSpecialChars(inPut); 1796 inPut = " "; 1797 OHOS::Url::DeleteC0OrSpace(inPut); 1798 inPut = " 123 "; 1799 OHOS::Url::DeleteC0OrSpace(inPut); 1800 inPut = "dks aasdd"; 1801 OHOS::Url::DeleteTabOrNewline(inPut); 1802 inPut = "1asdf"; 1803 std::string temp = ""; 1804 std::bitset<11> flags; // 11:Each bit of a BIT represents a different parsing state. 1805 bool isFalse = OHOS::Url::AnalysisScheme(inPut, temp, flags); 1806 ASSERT_FALSE(isFalse); 1807 inPut = "@Sdf"; 1808 OHOS::Url::AnalysisUsernameAndPasswd(inPut, temp, temp, flags); 1809 inPut = "12@3@222@Sdf"; 1810 OHOS::Url::AnalysisUsernameAndPasswd(inPut, temp, temp, flags); 1811 inPut = "../../"; 1812 std::vector<std::string> temp1; 1813 OHOS::Url::AnalysisPath(inPut, temp1, flags, true); 1814 inPut = "asd#sad"; 1815 OHOS::Url::AnalysisOpaqueHost(inPut, temp, flags); 1816 inPut = "asdsad"; 1817 OHOS::Url::AnalysisOpaqueHost(inPut, temp, flags); 1818 bool isHexDigit = OHOS::Url::IsHexDigit('/'); 1819 ASSERT_FALSE(isHexDigit); 1820} 1821 1822HWTEST_F(NativeEngineTest, testUrlutilities002, testing::ext::TestSize.Level0) 1823{ 1824 OHOS::Url::UrlData urlDataInfo; 1825 std::string inPut = "192.136.54.22"; 1826 std::string temp = ""; 1827 std::bitset<11> flags; 1828 OHOS::Url::DealIpv4(inPut); 1829 inPut = "1080:0:0:0:8:800:200C:417A"; 1830 OHOS::Url::FormatIpv6(inPut); 1831 inPut = "2136504"; 1832 size_t i = 0; 1833 OHOS::Url::SplitNum(inPut, i); 1834 inPut = "192.168.1.55"; 1835 OHOS::Url::AnalyseIPv4(inPut, temp, flags); 1836 inPut = ""; 1837 OHOS::Url::AnalysisHost(inPut, inPut, flags, true); 1838 inPut = "[asjdhkj"; 1839 OHOS::Url::AnalysisHost(inPut, inPut, flags, true); 1840 inPut = "f:11"; 1841 bool isTrue = OHOS::Url::ISFileNohost(inPut); 1842 ASSERT_TRUE(isTrue); 1843 inPut = "../../../"; 1844 OHOS::Url::AnalysisFilePath(inPut, urlDataInfo, flags); 1845 OHOS::Url::AnalysisFilescheme(inPut, urlDataInfo, flags); 1846 OHOS::Url::AnalyInfoPath(flags, urlDataInfo, inPut); 1847 inPut = "sadwasd"; 1848 OHOS::Url::AnalyHostPath(inPut, flags, urlDataInfo); 1849 inPut = "sad@wasd"; 1850 OHOS::Url::AnalyStrHost(inPut, urlDataInfo, flags); 1851 inPut = ""; 1852 OHOS::Url::AnalyStrHost(inPut, urlDataInfo, flags); 1853 inPut = "//sjalkjd"; 1854 urlDataInfo.scheme = "sa"; 1855 OHOS::Url::AnalysisNoDefaultProtocol(inPut, urlDataInfo, flags); 1856 inPut = "//sjalkjd"; 1857 urlDataInfo.scheme = ""; 1858 OHOS::Url::AnalysisNoDefaultProtocol(inPut, urlDataInfo, flags); 1859 inPut = ""; 1860 OHOS::Url::AnalysisOnlyHost(inPut, urlDataInfo, flags, i); 1861 bool isHexDigit = OHOS::Url::IsHexDigit('b'); 1862 ASSERT_TRUE(isHexDigit); 1863} 1864 1865std::string GetStringUtf8(napi_env env, napi_value str) 1866{ 1867 std::string buffer = ""; 1868 size_t bufferSize = 0; 1869 if (napi_get_value_string_utf8(env, str, nullptr, 0, &bufferSize) != napi_ok) { 1870 HILOG_ERROR("can not get src size"); 1871 return buffer; 1872 } 1873 buffer.resize(bufferSize); 1874 if (napi_get_value_string_utf8(env, str, buffer.data(), bufferSize + 1, &bufferSize) != napi_ok) { 1875 HILOG_ERROR("can not get src value"); 1876 return buffer; 1877 } 1878 return buffer; 1879} 1880 1881HWTEST_F(NativeEngineTest, testUrlModule001, testing::ext::TestSize.Level0) 1882{ 1883 napi_env env = (napi_env)engine_; 1884 napi_value exports = nullptr; 1885 napi_create_object(env, &exports); 1886 OHOS::Url::Init(env, exports); 1887 napi_value urlClass = nullptr; 1888 napi_value constructorArgs[1] = { 0 }; 1889 std::string input = "http://username:password@www.baidu.com:99/path/path?query#fagment"; 1890 napi_create_string_utf8(env, input.c_str(), input.size(), &constructorArgs[0]); 1891 napi_get_named_property(env, exports, "Url", &urlClass); 1892 napi_value instance = nullptr; 1893 napi_new_instance(env, urlClass, 1, constructorArgs, &instance); 1894 1895 std::string input1 = "www.example.com"; 1896 napi_value newValue = nullptr; 1897 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1898 napi_set_named_property(env, instance, "hostname", newValue); 1899 napi_value urlProperty = nullptr; 1900 napi_get_named_property(env, instance, "hostname", &urlProperty); 1901 std::string res = GetStringUtf8(env, urlProperty); 1902 ASSERT_STREQ(res.c_str(), "www.example.com"); 1903 1904 napi_value tempFn = nullptr; 1905 napi_get_named_property(env, instance, "onOrOff", &tempFn); 1906 bool res1 = false; 1907 napi_get_value_bool(env, tempFn, &res1); 1908 ASSERT_TRUE(res1); 1909 1910 napi_get_named_property(env, instance, "GetIsIpv6", &tempFn); 1911 res1 = true; 1912 napi_get_value_bool(env, tempFn, &res1); 1913 ASSERT_FALSE(res1); 1914 1915 input1 = "query1"; 1916 newValue = nullptr; 1917 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1918 napi_set_named_property(env, instance, "search", newValue); 1919 urlProperty = nullptr; 1920 napi_get_named_property(env, instance, "search", &urlProperty); 1921 res = GetStringUtf8(env, urlProperty); 1922 ASSERT_STREQ(res.c_str(), "?query1"); 1923 1924 input1 = "username1"; 1925 newValue = nullptr; 1926 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1927 napi_set_named_property(env, instance, "username", newValue); 1928 urlProperty = nullptr; 1929 napi_get_named_property(env, instance, "username", &urlProperty); 1930 res = GetStringUtf8(env, urlProperty); 1931 ASSERT_STREQ(res.c_str(), "username1"); 1932} 1933 1934HWTEST_F(NativeEngineTest, testUrlModule003, testing::ext::TestSize.Level0) 1935{ 1936 napi_env env = (napi_env)engine_; 1937 napi_value exports = nullptr; 1938 napi_create_object(env, &exports); 1939 OHOS::Url::Init(env, exports); 1940 napi_value urlClass = nullptr; 1941 napi_value constructorArgs[1] = { 0 }; 1942 std::string input = "http://username:password@www.baidu.com:99/path/path?query#fagment"; 1943 napi_create_string_utf8(env, input.c_str(), input.size(), &constructorArgs[0]); 1944 napi_get_named_property(env, exports, "Url", &urlClass); 1945 napi_value instance = nullptr; 1946 napi_new_instance(env, urlClass, 1, constructorArgs, &instance); 1947 1948 std::string input1 = "password1"; 1949 napi_value newValue = nullptr; 1950 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1951 napi_set_named_property(env, instance, "password", newValue); 1952 napi_value urlProperty = nullptr; 1953 napi_get_named_property(env, instance, "password", &urlProperty); 1954 std::string res = GetStringUtf8(env, urlProperty); 1955 ASSERT_STREQ(res.c_str(), "password1"); 1956 1957 input1 = "www.example.com:11"; 1958 newValue = nullptr; 1959 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1960 napi_set_named_property(env, instance, "host", newValue); 1961 urlProperty = nullptr; 1962 napi_get_named_property(env, instance, "host", &urlProperty); 1963 res = GetStringUtf8(env, urlProperty); 1964 ASSERT_STREQ(res.c_str(), "www.example.com:11"); 1965 1966 input1 = "fagment1"; 1967 newValue = nullptr; 1968 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1969 napi_set_named_property(env, instance, "hash", newValue); 1970 urlProperty = nullptr; 1971 napi_get_named_property(env, instance, "hash", &urlProperty); 1972 res = GetStringUtf8(env, urlProperty); 1973 ASSERT_STREQ(res.c_str(), "#fagment1"); 1974} 1975 1976HWTEST_F(NativeEngineTest, testUrlModule004, testing::ext::TestSize.Level0) 1977{ 1978 napi_env env = (napi_env)engine_; 1979 napi_value exports = nullptr; 1980 napi_create_object(env, &exports); 1981 OHOS::Url::Init(env, exports); 1982 napi_value urlClass = nullptr; 1983 napi_value constructorArgs[1] = { 0 }; 1984 std::string input = "http://username:password@www.baidu.com:99/path/path?query#fagment"; 1985 napi_create_string_utf8(env, input.c_str(), input.size(), &constructorArgs[0]); 1986 napi_get_named_property(env, exports, "Url", &urlClass); 1987 napi_value instance = nullptr; 1988 napi_new_instance(env, urlClass, 1, constructorArgs, &instance); 1989 1990 std::string input1 = "https:"; 1991 napi_value newValue = nullptr; 1992 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 1993 napi_set_named_property(env, instance, "protocol", newValue); 1994 napi_value urlProperty = nullptr; 1995 napi_get_named_property(env, instance, "protocol", &urlProperty); 1996 std::string res = GetStringUtf8(env, urlProperty); 1997 ASSERT_STREQ(res.c_str(), "https:"); 1998 1999 input1 = "/path/path1"; 2000 newValue = nullptr; 2001 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 2002 napi_set_named_property(env, instance, "pathname", newValue); 2003 urlProperty = nullptr; 2004 napi_get_named_property(env, instance, "pathname", &urlProperty); 2005 res = GetStringUtf8(env, urlProperty); 2006 ASSERT_STREQ(res.c_str(), "/path/path1"); 2007 2008 input1 = "55"; 2009 newValue = nullptr; 2010 napi_create_string_utf8(env, input1.c_str(), input1.size(), &newValue); 2011 napi_set_named_property(env, instance, "port", newValue); 2012 urlProperty = nullptr; 2013 napi_get_named_property(env, instance, "port", &urlProperty); 2014 res = GetStringUtf8(env, urlProperty); 2015 ASSERT_STREQ(res.c_str(), "55"); 2016 2017 napi_value constructorArgs1[1] = { 0 }; 2018 napi_create_string_utf8(env, input.c_str(), input.size(), &constructorArgs1[0]); 2019 napi_value hrefFn = nullptr; 2020 napi_get_named_property(env, instance, "href", &hrefFn); 2021 napi_value result1 = nullptr; 2022 napi_call_function(env, instance, hrefFn, 1, constructorArgs1, &result1); 2023 2024 urlProperty = nullptr; 2025 napi_get_named_property(env, instance, "port", &urlProperty); 2026 res = GetStringUtf8(env, urlProperty); 2027 ASSERT_STREQ(res.c_str(), "99"); 2028} 2029 2030HWTEST_F(NativeEngineTest, testUrlModule002, testing::ext::TestSize.Level0) 2031{ 2032 napi_env env = (napi_env)engine_; 2033 napi_value exports = nullptr; 2034 napi_create_object(env, &exports); 2035 OHOS::Url::Init(env, exports); 2036 napi_value urlParamsClass = nullptr; 2037 napi_get_named_property(env, exports, "URLParams1", &urlParamsClass); 2038 napi_value instance = nullptr; 2039 napi_new_instance(env, urlParamsClass, 0, nullptr, &instance); 2040 2041 napi_value paramsFn = nullptr; 2042 napi_get_named_property(env, instance, "append", ¶msFn); 2043 napi_value input1 = StrToNapiValue(env, "ma"); 2044 napi_value input2 = StrToNapiValue(env, "jk"); 2045 napi_value args[] = { input1, input2 }; 2046 napi_value result = nullptr; 2047 napi_call_function(env, instance, paramsFn, 2, args, &result); 2048 2049 paramsFn = nullptr; 2050 napi_get_named_property(env, instance, "set", ¶msFn); 2051 napi_value input3 = StrToNapiValue(env, "aa"); 2052 napi_value args1[] = { input1, input3 }; 2053 napi_call_function(env, instance, paramsFn, 2, args1, &result); 2054 2055 paramsFn = nullptr; 2056 napi_get_named_property(env, instance, "array", ¶msFn); 2057 std::string output = ""; 2058 std::vector<std::string> paramsString = GetParamsStrig(env, paramsFn); 2059 DealNapiStrValue(env, ToString(env, paramsString), output); 2060 ASSERT_STREQ(output.c_str(), "ma=aa"); 2061 napi_set_named_property(env, instance, "array", paramsFn); 2062 2063 paramsFn = nullptr; 2064 napi_get_named_property(env, instance, "has", ¶msFn); 2065 napi_value args2[1] = { input1 }; 2066 napi_call_function(env, instance, paramsFn, 1, args2, &result); 2067 bool res1 = false; 2068 napi_get_value_bool(env, result, &res1); 2069 ASSERT_TRUE(res1); 2070} 2071HWTEST_F(NativeEngineTest, testUrlModule005, testing::ext::TestSize.Level0) 2072{ 2073 napi_env env = (napi_env)engine_; 2074 napi_value exports = nullptr; 2075 napi_create_object(env, &exports); 2076 OHOS::Url::Init(env, exports); 2077 napi_value urlParamsClass = nullptr; 2078 napi_get_named_property(env, exports, "URLParams1", &urlParamsClass); 2079 napi_value instance = nullptr; 2080 napi_new_instance(env, urlParamsClass, 0, nullptr, &instance); 2081 std::string output = ""; 2082 napi_value paramsFn = nullptr; 2083 napi_get_named_property(env, instance, "append", ¶msFn); 2084 napi_value input1 = StrToNapiValue(env, "ma"); 2085 napi_value result = nullptr; 2086 2087 paramsFn = nullptr; 2088 napi_get_named_property(env, instance, "set", ¶msFn); 2089 napi_value input3 = StrToNapiValue(env, "aa"); 2090 napi_value args1[] = { input1, input3 }; 2091 napi_call_function(env, instance, paramsFn, 2, args1, &result); 2092 2093 paramsFn = nullptr; 2094 napi_get_named_property(env, instance, "sort", ¶msFn); 2095 napi_call_function(env, instance, paramsFn, 0, nullptr, &result); 2096 2097 paramsFn = nullptr; 2098 napi_get_named_property(env, instance, "keys", ¶msFn); 2099 napi_call_function(env, instance, paramsFn, 0, nullptr, &result); 2100 2101 paramsFn = nullptr; 2102 napi_get_named_property(env, instance, "values", ¶msFn); 2103 napi_call_function(env, instance, paramsFn, 0, nullptr, &result); 2104 2105 paramsFn = nullptr; 2106 napi_get_named_property(env, instance, "get", ¶msFn); 2107 2108 napi_value args3[1] = { input1 }; 2109 napi_call_function(env, instance, paramsFn, 1, args3, &result); 2110 DealNapiStrValue(env, result, output); 2111 ASSERT_STREQ(output.c_str(), "aa"); 2112 2113 paramsFn = nullptr; 2114 napi_get_named_property(env, instance, "getAll", ¶msFn); 2115 2116 napi_value args4[1] = { input1 }; 2117 napi_call_function(env, instance, paramsFn, 1, args4, &result); 2118 DealNapiStrValue(env, result, output); 2119 ASSERT_STREQ(output.c_str(), "aa"); 2120 2121 paramsFn = nullptr; 2122 napi_get_named_property(env, instance, "entries", ¶msFn); 2123 napi_call_function(env, instance, paramsFn, 0, nullptr, &result); 2124 2125 paramsFn = nullptr; 2126 napi_get_named_property(env, instance, "delete", ¶msFn); 2127 napi_value args5[1] = { input1 }; 2128 napi_call_function(env, instance, paramsFn, 1, args5, &result); 2129 DealNapiStrValue(env, result, output); 2130 ASSERT_STREQ(output.c_str(), "aa"); 2131} 2132HWTEST_F(NativeEngineTest, testUrlModule006, testing::ext::TestSize.Level0) 2133{ 2134 std::string inPut = "#1asdf"; 2135 std::string temp = ""; 2136 std::bitset<11> flags; // 11:Each bit of a BIT represents a different parsing state. 2137 bool isFalse = OHOS::Url::AnalysisScheme(inPut, temp, flags); 2138 ASSERT_FALSE(isFalse); 2139} 2140 2141HWTEST_F(NativeEngineTest, testUrlModule007, testing::ext::TestSize.Level0) 2142{ 2143 std::string inPut = ""; 2144 std::string temp = ""; 2145 std::bitset<11> flags(1023) ; // 11:Each bit of a BIT represents a different parsing state. 2146 OHOS::Url::AnalysisScheme(inPut, temp, flags); 2147 long a = flags.to_ulong(); 2148 ASSERT_EQ(a, 1023); 2149} 2150 2151HWTEST_F(NativeEngineTest, testUrlModule008, testing::ext::TestSize.Level0) 2152{ 2153 std::string inPut = "66666"; 2154 std::string temp = ""; 2155 std::bitset<11> flags(1023) ; // 11:Each bit of a BIT represents a different parsing state. 2156 OHOS::Url::AnalysisScheme(inPut, temp, flags); 2157 long a = flags.to_ulong(); 2158 ASSERT_EQ(a, 1023); 2159} 2160 2161HWTEST_F(NativeEngineTest, testUrlutilities009, testing::ext::TestSize.Level0) 2162{ 2163 std::string inPut = "99::1080:0:0:8:800:200C:417A"; 2164 OHOS::Url::FormatIpv6(inPut); 2165 ASSERT_STREQ(inPut.c_str(), "99:1080:0:0:8:800:200C:417A"); 2166 inPut = "::99:1080:0:0:8:800:200C:417A"; 2167 OHOS::Url::FormatIpv6(inPut); 2168 ASSERT_STREQ(inPut.c_str(), "0:99:1080:0:0:8:800:200C:417A"); 2169} 2170 2171HWTEST_F(NativeEngineTest, testUrlutilities010, testing::ext::TestSize.Level0) 2172{ 2173 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 2174 std::string str = "0x.23.56"; 2175 url.SetHostname(str); 2176 ASSERT_STREQ(str.c_str(), "0x.23.56"); 2177} 2178 2179HWTEST_F(NativeEngineTest, testUrlutilities011, testing::ext::TestSize.Level0) 2180{ 2181 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 2182 std::string str = "0.23.56"; 2183 url.SetHostname(str); 2184 ASSERT_STREQ(str.c_str(), "0.23.56"); 2185} 2186 2187HWTEST_F(NativeEngineTest, testUrlutilities012, testing::ext::TestSize.Level0) 2188{ 2189 OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html"); 2190 std::string str = "33.""."; 2191 url.SetHostname(str); 2192 ASSERT_STREQ(str.c_str(), "33.."); 2193} 2194 2195HWTEST_F(NativeEngineTest, testUrlutilities013, testing::ext::TestSize.Level0) 2196{ 2197 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 2198 std::string str = "111111111.1001000.111.10101"; 2199 url.SetHost(str); 2200 ASSERT_STREQ(str.c_str(), "111111111.1001000.111.10101"); 2201} 2202 2203HWTEST_F(NativeEngineTest, testUrlutilities014, testing::ext::TestSize.Level0) 2204{ 2205 OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment"); 2206 std::string str = "10.11.11111111"; 2207 url.SetHost(str); 2208 ASSERT_STREQ(str.c_str(), "10.11.11111111"); 2209} 2210 2211HWTEST_F(NativeEngineTest, testUrlutilities015, testing::ext::TestSize.Level0) 2212{ 2213 std::string str = "hello world!"; 2214 size_t number = 0; 2215 OHOS::Url::SplitNum(str, number); 2216 ASSERT_STREQ(str.c_str(), "hello world!"); 2217} 2218 2219HWTEST_F(NativeEngineTest, testUrlutilities016, testing::ext::TestSize.Level0) 2220{ 2221 std::string input = "H+#LLOWORLD"; 2222 std::string scheme = ""; 2223 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2224 bool rst = OHOS::Url::AnalysisScheme(input, scheme, flags); 2225 ASSERT_FALSE(rst); 2226} 2227 2228HWTEST_F(NativeEngineTest, testUrlutilities017, testing::ext::TestSize.Level0) 2229{ 2230 std::string input = "H+#LLOWORLD:"; 2231 OHOS::Url::UrlData urlinfo; 2232 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2233 size_t pos = 0; 2234 OHOS::Url::AnalysisOnlyHost(input, urlinfo, flags, pos); 2235 ASSERT_STREQ(input.c_str(), "H+#LLOWORLD:"); 2236} 2237 2238HWTEST_F(NativeEngineTest, testUrlutilities018, testing::ext::TestSize.Level0) 2239{ 2240 std::string input = "H+#LLOWORLD:65536"; 2241 OHOS::Url::UrlData urlinfo; 2242 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2243 size_t pos = 0; 2244 OHOS::Url::AnalysisOnlyHost(input, urlinfo, flags, pos); 2245 ASSERT_STREQ(input.c_str(), "H+#LLOWORLD:65536"); 2246} 2247 2248HWTEST_F(NativeEngineTest, testUrlutilities019, testing::ext::TestSize.Level0) 2249{ 2250 std::string input01 = "256"; 2251 std::vector<std::string> nums; 2252 nums.push_back(input01); 2253 std::string host; 2254 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2255 OHOS::Url::FormatIpv4(nums, host, flags); 2256 ASSERT_STREQ(host.c_str(), "0.0.1.0"); 2257} 2258 2259HWTEST_F(NativeEngineTest, testUrlutilities020, testing::ext::TestSize.Level0) 2260{ 2261 std::string input = "abcdefghi"; 2262 std::string input01 = "1"; 2263 std::string input02 = "2"; 2264 std::vector<std::string> nums; 2265 nums.push_back(input); 2266 nums.push_back(input01); 2267 nums.push_back(input02); 2268 std::string host; 2269 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2270 OHOS::Url::FormatIpv4(nums, host, flags); 2271 ASSERT_EQ(nums.size(), 3); 2272} 2273 2274HWTEST_F(NativeEngineTest, testUrlutilities021, testing::ext::TestSize.Level0) 2275{ 2276 std::string input = "155.155.256.111111111"; 2277 std::string host; 2278 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2279 OHOS::Url::AnalyseIPv4(input, host, flags); 2280 ASSERT_STREQ(input.c_str(), "155.155.256.111111111"); 2281} 2282 2283HWTEST_F(NativeEngineTest, testUrlutilities022, testing::ext::TestSize.Level0) 2284{ 2285 std::string input = "http://example.com/path/.%2E/to%2eresource"; 2286 OHOS::Url::UrlData urlinfo; 2287 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2288 OHOS::Url::AnalysisFilePath(input, urlinfo, flags); 2289 ASSERT_STREQ(input.c_str(), "to%2eresource"); 2290} 2291 2292HWTEST_F(NativeEngineTest, testUrlutilities023, testing::ext::TestSize.Level0) 2293{ 2294 std::string input = "http://example.com/path/to%2eresource/%2E"; 2295 OHOS::Url::UrlData urlinfo; 2296 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2297 OHOS::Url::AnalysisFilePath(input, urlinfo, flags); 2298 ASSERT_STREQ(input.c_str(), "%2E"); 2299} 2300 2301HWTEST_F(NativeEngineTest, testUrlutilities024, testing::ext::TestSize.Level0) 2302{ 2303 std::string input = ".%2E"; 2304 OHOS::Url::UrlData urlinfo; 2305 std::string str = "h:"; 2306 urlinfo.path.push_back(str); 2307 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2308 OHOS::Url::AnalysisFilePath(input, urlinfo, flags); 2309 ASSERT_STREQ(input.c_str(), ".%2E"); 2310} 2311 2312HWTEST_F(NativeEngineTest, testUrlutilities025, testing::ext::TestSize.Level0) 2313{ 2314 std::string input = ".%2E"; 2315 OHOS::Url::UrlData urlinfo; 2316 std::string str = "w:"; 2317 urlinfo.path.push_back(str); 2318 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2319 OHOS::Url::AnalysisFilePath(input, urlinfo, flags); 2320 ASSERT_STREQ(input.c_str(), ".%2E"); 2321} 2322 2323HWTEST_F(NativeEngineTest, testUrlutilities026, testing::ext::TestSize.Level0) 2324{ 2325 std::string input = ".%2E"; 2326 OHOS::Url::UrlData urlinfo; 2327 std::string str = "z:"; 2328 urlinfo.path.push_back(str); 2329 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2330 OHOS::Url::AnalysisFilePath(input, urlinfo, flags); 2331 ASSERT_STREQ(input.c_str(), ".%2E"); 2332} 2333 2334HWTEST_F(NativeEngineTest, testUrlutilities027, testing::ext::TestSize.Level0) 2335{ 2336 std::string temp = "w:51"; 2337 size_t pos = 2; 2338 OHOS::Url::UrlData urlinfo; 2339 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2340 OHOS::Url::AnalysisSpecialFile(temp, pos, urlinfo, flags); 2341 ASSERT_STREQ(temp.c_str(), "w:51"); 2342} 2343 2344HWTEST_F(NativeEngineTest, testUrlutilities028, testing::ext::TestSize.Level0) 2345{ 2346 std::string input = "/g";; 2347 OHOS::Url::UrlData urlinfo; 2348 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2349 OHOS::Url::AnalysisFile(input, urlinfo, flags); 2350 ASSERT_STREQ(input.c_str(), "g"); 2351} 2352 2353HWTEST_F(NativeEngineTest, testUrlutilities029, testing::ext::TestSize.Level0) 2354{ 2355 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2356 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2357 std::string input = "//abc"; 2358 OHOS::Url::UrlData urlinfo; 2359 OHOS::Url::AnalysisFile(input, urlinfo, flags); 2360 ASSERT_STREQ(input.c_str(), "//abc"); 2361} 2362 2363HWTEST_F(NativeEngineTest, testUrlutilities030, testing::ext::TestSize.Level0) 2364{ 2365 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2366 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2367 std::string input = "/abc"; 2368 OHOS::Url::UrlData urlinfo; 2369 OHOS::Url::AnalyInfoPath(flags, urlinfo, input); 2370 ASSERT_STREQ(input.c_str(), "/abc"); 2371} 2372 2373HWTEST_F(NativeEngineTest, testUrlutilities031, testing::ext::TestSize.Level0) 2374{ 2375 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2376 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2377 std::string input = ":h"; 2378 OHOS::Url::UrlData urlinfo; 2379 OHOS::Url::AnalyHostPath(input, flags, urlinfo); 2380 ASSERT_TRUE(flags[0]); 2381} 2382 2383HWTEST_F(NativeEngineTest, testUrlutilities032, testing::ext::TestSize.Level0) 2384{ 2385 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2386 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2387 std::string input = "///"; 2388 OHOS::Url::UrlData urlinfo; 2389 OHOS::Url::AnalysisNoDefaultProtocol(input, urlinfo, flags); 2390 ASSERT_STREQ(input.c_str(), "///"); 2391} 2392 2393HWTEST_F(NativeEngineTest, testUrlutilities033, testing::ext::TestSize.Level0) 2394{ 2395 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2396 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2397 std::string input = "//"; 2398 OHOS::Url::UrlData urlinfo; 2399 OHOS::Url::AnalysisNoDefaultProtocol(input, urlinfo, flags); 2400 ASSERT_STREQ(input.c_str(), "//"); 2401} 2402 2403HWTEST_F(NativeEngineTest, testUrlutilities034, testing::ext::TestSize.Level0) 2404{ 2405 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2406 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2407 std::string input = "//::/"; 2408 OHOS::Url::UrlData urlinfo; 2409 OHOS::Url::AnalysisNoDefaultProtocol(input, urlinfo, flags); 2410 ASSERT_STREQ(input.c_str(), "//::/"); 2411} 2412 2413HWTEST_F(NativeEngineTest, testUrlutilities035, testing::ext::TestSize.Level0) 2414{ 2415 std::string input = "abc:d:e"; 2416 OHOS::Url::UrlData urlinfo; 2417 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2418 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2419 size_t pos = 0; 2420 OHOS::Url::AnalysisOnlyHost(input, urlinfo, flags, pos); 2421 ASSERT_STREQ(input.c_str(), "abc:d:e"); 2422} 2423 2424HWTEST_F(NativeEngineTest, testUrlutilities036, testing::ext::TestSize.Level0) 2425{ 2426 std::string input = "abc:d:e/fg"; 2427 OHOS::Url::UrlData urlinfo; 2428 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2429 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2430 size_t pos = 6; // 6:string position 2431 OHOS::Url::ParsingHostAndPath(input, urlinfo, pos, flags); 2432 ASSERT_STREQ(input.c_str(), "abc:d:e/fg"); 2433} 2434 2435HWTEST_F(NativeEngineTest, testUrlutilities037, testing::ext::TestSize.Level0) 2436{ 2437 OHOS::Url::UrlData urlData; 2438 OHOS::Url::UrlData baseData; 2439 baseData.path.push_back(""); 2440 urlData.path.push_back(""); 2441 bool isFile = false; 2442 OHOS::Url::ShorteningPath(urlData, baseData, isFile); 2443 ASSERT_FALSE(isFile); 2444} 2445 2446HWTEST_F(NativeEngineTest, testUrlutilities038, testing::ext::TestSize.Level0) 2447{ 2448 OHOS::Url::UrlData urlData; 2449 OHOS::Url::UrlData baseData; 2450 baseData.path.push_back("a:"); 2451 urlData.path.push_back("a"); 2452 bool isFile = true; 2453 OHOS::Url::ShorteningPath(urlData, baseData, isFile); 2454 ASSERT_TRUE(isFile); 2455} 2456 2457HWTEST_F(NativeEngineTest, testUrlutilities040, testing::ext::TestSize.Level0) 2458{ 2459 std::string input = ".%2E"; 2460 std::vector<std::string> path; 2461 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2462 bool isSpecial = true; 2463 OHOS::Url::AnalysisPath(input, path, flags, isSpecial); 2464 ASSERT_STREQ(input.c_str(), ".%2E"); 2465} 2466 2467HWTEST_F(NativeEngineTest, testUrlutilities041, testing::ext::TestSize.Level0) 2468{ 2469 std::string input = "%2E"; 2470 std::vector<std::string> path; 2471 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2472 bool isSpecial = true; 2473 OHOS::Url::AnalysisPath(input, path, flags, isSpecial); 2474 ASSERT_STREQ(input.c_str(), "%2E"); 2475} 2476 2477HWTEST_F(NativeEngineTest, testUrlutilities042, testing::ext::TestSize.Level0) 2478{ 2479 std::string input = "99::1080:800:200C:417A"; 2480 OHOS::Url::FormatIpv6(input); 2481 ASSERT_STREQ(input.c_str(), "99:0:0:0:1080:800:200C:417A"); 2482} 2483 2484HWTEST_F(NativeEngineTest, testUrlutilities043, testing::ext::TestSize.Level0) 2485{ 2486 std::string input = "000:1080:800:200C:417A"; 2487 std::vector<std::string> ipv6; 2488 ipv6.push_back(input); 2489 OHOS::Url::RemoveLeadingZeros(ipv6); 2490 ASSERT_STREQ(input.c_str(), "000:1080:800:200C:417A"); 2491} 2492 2493HWTEST_F(NativeEngineTest, testUrlutilities044, testing::ext::TestSize.Level0) 2494{ 2495 std::string input = "::ffff:192.168.1.1"; 2496 std::string host = ""; 2497 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2498 OHOS::Url::IPv6Host(input, host, flags); 2499 ASSERT_STREQ(input.c_str(), "::ffff:c0a8:101"); 2500} 2501 2502HWTEST_F(NativeEngineTest, testUrlutilities045, testing::ext::TestSize.Level0) 2503{ 2504 std::string input = "w"; 2505 OHOS::Url::UrlData urlinfo; 2506 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2507 OHOS::Url::AnalysisNoDefaultProtocol(input, urlinfo, flags); 2508 ASSERT_STREQ(input.c_str(), "w"); 2509} 2510 2511HWTEST_F(NativeEngineTest, testUrlutilities046, testing::ext::TestSize.Level0) 2512{ 2513 std::string input = "ww:w]wa:b]c/www"; 2514 OHOS::Url::UrlData urlinfo; 2515 size_t pos; 2516 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2517 flags.set(static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT0)); 2518 OHOS::Url::ParsingHostAndPath(input, urlinfo, pos, flags); 2519 ASSERT_STREQ(input.c_str(), "ww:w]wa:b]c/www"); 2520} 2521 2522HWTEST_F(NativeEngineTest, testUrlutilities047, testing::ext::TestSize.Level0) 2523{ 2524 OHOS::Url::UrlData urlData; 2525 std::string s1 = "www"; 2526 std::string s2 = "aaa"; 2527 std::string s3 = "bbb"; 2528 std::string s4 = "ccc"; 2529 urlData.path.push_back(s1); 2530 urlData.path.push_back(s2); 2531 urlData.path.push_back(s3); 2532 urlData.path.push_back(s4); 2533 std::string rst = OHOS::Url::BasePathToStr(urlData); 2534 ASSERT_STREQ(rst.c_str(), "www/aaa/bbb/ccc"); 2535} 2536 2537HWTEST_F(NativeEngineTest, testUrlutilities048, testing::ext::TestSize.Level0) 2538{ 2539 std::vector<std::string> ipv6; 2540 std::string str = "00ccccc"; 2541 ipv6.push_back(str); 2542 OHOS::Url::RemoveLeadingZeros(ipv6); 2543 ASSERT_STREQ(str.c_str(), "00ccccc"); 2544} 2545 2546HWTEST_F(NativeEngineTest, testUrlutilities049, testing::ext::TestSize.Level0) 2547{ 2548 std::string input = "//@/aabab"; 2549 OHOS::Url::UrlData urlinfo; 2550 std::bitset<static_cast<size_t>(OHOS::Url::BitsetStatusFlag::BIT_STATUS_11)> flags; 2551 OHOS::Url::AnalysisNoDefaultProtocol(input, urlinfo, flags); 2552 ASSERT_STREQ(input.c_str(), "//@/aabab"); 2553} 2554 2555HWTEST_F(NativeEngineTest, testUrlutilities050, testing::ext::TestSize.Level0) 2556{ 2557 std::string input = "99::1080:8:800:200C:417A"; 2558 OHOS::Url::FormatIpv6(input); 2559 ASSERT_STREQ(input.c_str(), "99:0:0:1080:8:800:200C:417A"); 2560}