• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "utils/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 
27 #define ASSERT_CHECK_CALL(call)   \
28     {                             \
29         ASSERT_EQ(call, napi_ok); \
30     }
31 
32 #define ASSERT_CHECK_VALUE_TYPE(env, value, type)               \
33     {                                                           \
34         napi_valuetype valueType = napi_undefined;              \
35         ASSERT_TRUE(value != nullptr);                          \
36         ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
37         ASSERT_EQ(valueType, type);                             \
38     }
39 
DealNapiStrValue(napi_env env,const napi_value napiStr,std::string & result)40 napi_status DealNapiStrValue(napi_env env, const napi_value napiStr, std::string &result)
41 {
42     std::string buffer = "";
43     size_t bufferSize = 0;
44     napi_status status = napi_ok;
45     status = napi_get_value_string_utf8(env, napiStr, nullptr, -1, &bufferSize);
46     buffer.reserve(bufferSize + 1);
47     buffer.resize(bufferSize);
48     if (status != napi_ok) {
49         HILOG_ERROR("can not get buffer size");
50         return status;
51     }
52     if (bufferSize > 0) {
53         status = napi_get_value_string_utf8(env, napiStr, buffer.data(), bufferSize + 1, &bufferSize);
54         if (status != napi_ok) {
55             HILOG_ERROR("can not get buffer value");
56             return status;
57         }
58     }
59     if (buffer.data() != nullptr) {
60         result = buffer;
61     }
62     return status;
63 }
64 
StrToNapiValue(napi_env env,const std::string & result)65 napi_value StrToNapiValue(napi_env env, const std::string &result)
66 {
67     napi_value output = nullptr;
68     napi_create_string_utf8(env, result.c_str(), result.size(), &output);
69     return output;
70 }
71 
IsEscapeRange(const char ch)72 bool IsEscapeRange(const char ch)
73 {
74     if ((ch > 0 && ch < '*') || (ch > '*' && ch < '-') || (ch == '/') ||
75         (ch > '9' && ch < 'A') || (ch > 'Z' && ch < '_') || (ch == '`') || (ch > 'z')) {
76         return true;
77     }
78     return false;
79 }
80 
ReviseStr(std::string & str,std::string * reviseChar)81 std::string ReviseStr(std::string &str, std::string *reviseChar)
82 {
83     icu::StringPiece sp(str.c_str());
84     icu::UnicodeString wstr = icu::UnicodeString::fromUTF8(sp);
85     const size_t lenStr = static_cast<size_t>(wstr.length());
86     if (lenStr == 0) {
87         return "";
88     }
89     std::string output = "";
90     size_t numOfAscii = 128; // 128:Number of ASCII characters
91     size_t i = 0;
92     for (; i < lenStr; i++) {
93         auto charaEncode = static_cast<size_t>(wstr[i]);
94         if (charaEncode < numOfAscii) {
95             // 2:Defines the escape range of ASCII characters
96             if (IsEscapeRange(charaEncode)) {
97                 output += reviseChar[charaEncode];
98             } else {
99                 output += str.substr(i, 1);
100             }
101         } else if (charaEncode <= 0x000007FF) { // Convert the Unicode code into two bytes
102             std::string output1 = reviseChar[0x000000C0 | (charaEncode / 64)]; // 64:the first byte
103             std::string output2 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)];
104             output += output1 + output2;
105         } else if ((charaEncode >= 0x0000E000) || (charaEncode <= 0x0000D7FF)) {
106             std::string output1 = reviseChar[0x000000E0 | (charaEncode / 4096)]; // 4096:Acquisition method
107             std::string output2 = reviseChar[numOfAscii | ((charaEncode / 64) & 0x0000003F)]; // 64:second byte
108             std::string output3 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)];
109             output += output1 + output2 + output3;
110         } else {
111             const size_t charaEncode1 = static_cast<size_t>(str[++i]) & 1023; // 1023:Convert codes
112             charaEncode = 65536 + (((charaEncode & 1023) << 10) | charaEncode1); // 65536:Specific transcoding
113             std::string output1 = reviseChar[0x000000F0 | (charaEncode / 262144)]; // 262144:the first byte
114             std::string output2 = reviseChar[numOfAscii | ((charaEncode / 4096) & 0x0000003F)]; // 4096:second byte
115             std::string output3 = reviseChar[numOfAscii | ((charaEncode / 64) & 0x0000003F)]; // 64:third byte
116             std::string output4 = reviseChar[numOfAscii | (charaEncode & 0x0000003F)];
117             output += output1 + output2 + output3 + output4;
118         }
119     }
120     return output;
121 }
122 
ToString(napi_env env,std::vector<std::string> & searchParams)123 napi_value ToString(napi_env env, std::vector<std::string> &searchParams)
124 {
125     std::string output = "";
126     std::string reviseChar[256] = {""}; // 256:Array length
127     for (size_t i = 0; i < 256; ++i) { // 256:Array length
128         size_t j = i;
129         std::stringstream ioss;
130         std::string str1 = "";
131         ioss << std::hex << j;
132         ioss >> str1;
133         transform(str1.begin(), str1.end(), str1.begin(), ::toupper);
134         if (i < 16) { // 16:Total number of 0-F
135             reviseChar[i] = '%' + ("0" + str1);
136         } else {
137             reviseChar[i] = '%' + str1;
138         }
139     }
140     reviseChar[0x20] = "+"; // 0x20:ASCII value of spaces
141     const size_t lenStr = searchParams.size();
142     napi_value result = nullptr;
143     if (lenStr == 0) {
144         napi_create_string_utf8(env, output.c_str(), output.size(), &result);
145         return result;
146     }
147     std::string firstStrKey = ReviseStr(searchParams[0], reviseChar);
148     std::string firstStrValue = ReviseStr(searchParams[1], reviseChar);
149     output = firstStrKey + "=" + firstStrValue;
150     if (lenStr % 2 == 0) { // 2:Divisible by 2
151         size_t pos = 2; // 2:Initial Position
152         for (; pos < lenStr; pos += 2) { // 2:Searching for the number and number of keys and values
153             std::string strKey = ReviseStr(searchParams[pos], reviseChar);
154             std::string strValue = ReviseStr(searchParams[pos + 1], reviseChar);
155             output += +"&" + strKey + "=" + strValue;
156         }
157     }
158     napi_create_string_utf8(env, output.c_str(), output.size(), &result);
159     return result;
160 }
161 
GetParamsStrig(napi_env env,const napi_value tempStr)162 std::vector<std::string> GetParamsStrig(napi_env env, const napi_value tempStr)
163 {
164     std::vector<std::string> vec;
165     size_t arraySize = 0;
166     uint32_t length = 0;
167     napi_get_array_length(env, tempStr, &length);
168     napi_value napiStr = nullptr;
169     for (size_t i = 0; i < length; i++) {
170         napi_get_element(env, tempStr, i, &napiStr);
171         if (napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize) != napi_ok) {
172             HILOG_ERROR("can not get napiStr size");
173             return vec;
174         }
175         if (arraySize > 0) {
176             std::string cstr = "";
177             cstr.resize(arraySize);
178             if (napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize) != napi_ok) {
179                 HILOG_ERROR("can not get napiStr size");
180                 return vec;
181             }
182             vec.push_back(cstr);
183         } else {
184             vec.push_back("");
185         }
186     }
187     return vec;
188 }
189 
190 HWTEST_F(NativeEngineTest, testUrlConstructs001, testing::ext::TestSize.Level0)
191 {
192     OHOS::Url::URL url("https://example.org:81/a/b/c?query#fragment");
193     std::string output;
194     napi_env env = (napi_env)engine_;
195     DealNapiStrValue(env, url.GetPath(env), output);
196     ASSERT_STREQ(output.c_str(), "/a/b/c");
197 }
198 
199 HWTEST_F(NativeEngineTest, testUrlConstructs002, testing::ext::TestSize.Level0)
200 {
201     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
202     std::string output;
203     napi_env env = (napi_env)engine_;
204     DealNapiStrValue(env, url.GetPath(env), output);
205     ASSERT_STREQ(output.c_str(), "/directory/file");
206 }
207 
208 HWTEST_F(NativeEngineTest, testUrlConstructs003, testing::ext::TestSize.Level0)
209 {
210     OHOS::Url::URL url("../baz", "http://example.org/foo/bar");
211     std::string output;
212     napi_env env = (napi_env)engine_;
213     DealNapiStrValue(env, url.GetPath(env), output);
214     ASSERT_STREQ(output.c_str(), "/foo/baz");
215 }
216 
217 HWTEST_F(NativeEngineTest, testUrlConstructs004, testing::ext::TestSize.Level0)
218 {
219     OHOS::Url::URL url("/../sca/./path/path/../scasa/jjjjj", "http://www.example.com");
220     std::string output;
221     napi_env env = (napi_env)engine_;
222     DealNapiStrValue(env, url.GetPath(env), output);
223     ASSERT_STREQ(output.c_str(), "/sca/path/scasa/jjjjj");
224 }
225 
226 HWTEST_F(NativeEngineTest, testUrlConstructs005, testing::ext::TestSize.Level0)
227 {
228     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
229     std::string output;
230     napi_env env = (napi_env)engine_;
231     DealNapiStrValue(env, url.GetScheme(env), output);
232     ASSERT_STREQ(output.c_str(), "http:");
233 }
234 
235 HWTEST_F(NativeEngineTest, testUrlConstructs006, testing::ext::TestSize.Level0)
236 {
237     OHOS::Url::URL base("http://www.example.com");
238     OHOS::Url::URL url("//sca/./path/./scasa#", base);
239     std::string output;
240     napi_env env = (napi_env)engine_;
241     DealNapiStrValue(env, url.GetPath(env), output);
242     ASSERT_STREQ(output.c_str(), "/path/scasa");
243 }
244 
245 HWTEST_F(NativeEngineTest, testUrlConstructs007, testing::ext::TestSize.Level0)
246 {
247     OHOS::Url::URL base("http://www.example.com");
248     OHOS::Url::URL url("/dire/query", base);
249     std::string output;
250     napi_env env = (napi_env)engine_;
251     DealNapiStrValue(env, url.GetPath(env), output);
252     ASSERT_STREQ(output.c_str(), "/dire/query");
253 }
254 
255 HWTEST_F(NativeEngineTest, testUrlConstructs008, testing::ext::TestSize.Level0)
256 {
257     OHOS::Url::URL base("http://www.example.com");
258     OHOS::Url::URL url("foo/bar//fragment", base);
259     std::string output;
260     napi_env env = (napi_env)engine_;
261     DealNapiStrValue(env, url.GetPath(env), output);
262     ASSERT_STREQ(output.c_str(), "/foo/bar//fragment");
263 }
264 
265 HWTEST_F(NativeEngineTest, testUrlConstructs009, testing::ext::TestSize.Level0)
266 {
267     OHOS::Url::URL base("http://www.example.com");
268     OHOS::Url::URL url("/../sca/./path/./s#casa", base);
269     std::string output;
270     napi_env env = (napi_env)engine_;
271     DealNapiStrValue(env, url.GetPath(env), output);
272     ASSERT_STREQ(output.c_str(), "/sca/path/s");
273 }
274 
275 HWTEST_F(NativeEngineTest, testUrlConstructs010, testing::ext::TestSize.Level0)
276 {
277     OHOS::Url::URL base("http://www.example.com");
278     OHOS::Url::URL url("/../sca/./path/./sca?sa", base);
279     std::string output;
280     napi_env env = (napi_env)engine_;
281     DealNapiStrValue(env, url.GetPath(env), output);
282     ASSERT_STREQ(output.c_str(), "/sca/path/sca");
283 }
284 
285 HWTEST_F(NativeEngineTest, testUrlConstructs011, testing::ext::TestSize.Level0)
286 {
287     OHOS::Url::URL base("http://www.example.com");
288     OHOS::Url::URL url("", base);
289     std::string output;
290     napi_env env = (napi_env)engine_;
291     DealNapiStrValue(env, url.GetPath(env), output);
292     ASSERT_STREQ(output.c_str(), "/");
293 }
294 
295 HWTEST_F(NativeEngineTest, testUrlConstructs012, testing::ext::TestSize.Level0)
296 {
297     OHOS::Url::URL url("file://\\/www.example.com");
298     std::string output;
299     napi_env env = (napi_env)engine_;
300     DealNapiStrValue(env, url.GetScheme(env), output);
301     ASSERT_STREQ(output.c_str(), "file:");
302 }
303 
304 HWTEST_F(NativeEngineTest, testUrlConstructs013, testing::ext::TestSize.Level0)
305 {
306     OHOS::Url::URL url("file:///www.example.com");
307     std::string output;
308     napi_env env = (napi_env)engine_;
309     DealNapiStrValue(env, url.GetScheme(env), output);
310     ASSERT_STREQ(output.c_str(), "file:");
311 }
312 
313 HWTEST_F(NativeEngineTest, testUrlProtocol001, testing::ext::TestSize.Level0)
314 {
315     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
316     std::string output;
317     napi_env env = (napi_env)engine_;
318     DealNapiStrValue(env, url.GetScheme(env), output);
319     ASSERT_STREQ(output.c_str(), "http:");
320 }
321 
322 HWTEST_F(NativeEngineTest, testUrlProtocol002, testing::ext::TestSize.Level0)
323 {
324     OHOS::Url::URL url("ftp://username:password@host:8080/directory/file?query#fragment");
325     std::string output;
326     napi_env env = (napi_env)engine_;
327     DealNapiStrValue(env, url.GetScheme(env), output);
328     ASSERT_STREQ(output.c_str(), "ftp:");
329 }
330 
331 HWTEST_F(NativeEngineTest, testUrlProtocol003, testing::ext::TestSize.Level0)
332 {
333     OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment");
334     std::string output;
335     napi_env env = (napi_env)engine_;
336     DealNapiStrValue(env, url.GetScheme(env), output);
337     ASSERT_STREQ(output.c_str(), "https:");
338 }
339 
340 HWTEST_F(NativeEngineTest, testUrlSetScheme001, testing::ext::TestSize.Level0)
341 {
342     OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment");
343     std::string output;
344     napi_env env = (napi_env)engine_;
345     DealNapiStrValue(env, url.GetScheme(env), output);
346     ASSERT_STREQ(output.c_str(), "https:");
347     url.SetScheme("ftp:");
348     DealNapiStrValue(env, url.GetScheme(env), output);
349     ASSERT_STREQ(output.c_str(), "ftp:");
350 }
351 
352 HWTEST_F(NativeEngineTest, testUrlSetScheme002, testing::ext::TestSize.Level0)
353 {
354     OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment");
355     std::string output;
356     napi_env env = (napi_env)engine_;
357     DealNapiStrValue(env, url.GetScheme(env), output);
358     ASSERT_STREQ(output.c_str(), "https:");
359     url.SetScheme("666");
360     DealNapiStrValue(env, url.GetScheme(env), output);
361     ASSERT_STREQ(output.c_str(), "https:");
362 }
363 
364 HWTEST_F(NativeEngineTest, testUrlSetScheme003, testing::ext::TestSize.Level0)
365 {
366     OHOS::Url::URL url("https://username:password@host:8080/directory/file?query#fragment");
367     std::string output;
368     napi_env env = (napi_env)engine_;
369     DealNapiStrValue(env, url.GetScheme(env), output);
370     ASSERT_STREQ(output.c_str(), "https:");
371     url.SetScheme("-/+");
372     DealNapiStrValue(env, url.GetScheme(env), output);
373     ASSERT_STREQ(output.c_str(), "https:");
374 }
375 
376 HWTEST_F(NativeEngineTest, testUrlUsername001, testing::ext::TestSize.Level0)
377 {
378     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
379     std::string output;
380     napi_env env = (napi_env)engine_;
381     DealNapiStrValue(env, url.GetUsername(env), output);
382     ASSERT_STREQ(output.c_str(), "username");
383 }
384 
385 HWTEST_F(NativeEngineTest, testUrlUsername002, testing::ext::TestSize.Level0)
386 {
387     OHOS::Url::URL url("http://zhao:password@host:8080/directory/file?query#fragment");
388     std::string output;
389     napi_env env = (napi_env)engine_;
390     DealNapiStrValue(env, url.GetUsername(env), output);
391     ASSERT_STREQ(output.c_str(), "zhao");
392 }
393 
394 HWTEST_F(NativeEngineTest, testUrlUsername003, testing::ext::TestSize.Level0)
395 {
396     OHOS::Url::URL url("http://skk:password@host:8080/directory/file?query#fragment");
397     std::string output;
398     napi_env env = (napi_env)engine_;
399     DealNapiStrValue(env, url.GetUsername(env), output);
400     ASSERT_STREQ(output.c_str(), "skk");
401 }
402 
403 HWTEST_F(NativeEngineTest, testUrlSetUsername001, testing::ext::TestSize.Level0)
404 {
405     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
406     std::string output;
407     napi_env env = (napi_env)engine_;
408     DealNapiStrValue(env, url.GetUsername(env), output);
409     ASSERT_STREQ(output.c_str(), "username");
410     url.SetUsername("666");
411     DealNapiStrValue(env, url.GetUsername(env), output);
412     ASSERT_STREQ(output.c_str(), "666");
413 }
414 
415 HWTEST_F(NativeEngineTest, testUrlSetUsername002, testing::ext::TestSize.Level0)
416 {
417     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
418     std::string output;
419     napi_env env = (napi_env)engine_;
420     DealNapiStrValue(env, url.GetUsername(env), output);
421     ASSERT_STREQ(output.c_str(), "username");
422     url.SetUsername("");
423     DealNapiStrValue(env, url.GetUsername(env), output);
424     ASSERT_STREQ(output.c_str(), "");
425 }
426 
427 HWTEST_F(NativeEngineTest, testUrlPassword001, testing::ext::TestSize.Level0)
428 {
429     OHOS::Url::URL url("http://username:11@host:8080/directory/file?query#fragment");
430     std::string output;
431     napi_env env = (napi_env)engine_;
432     DealNapiStrValue(env, url.GetPassword(env), output);
433     ASSERT_STREQ(output.c_str(), "11");
434 }
435 
436 HWTEST_F(NativeEngineTest, testUrlPassword002, testing::ext::TestSize.Level0)
437 {
438     OHOS::Url::URL url("http://username:23aa@host:8080/directory/file?query#fragment");
439     std::string output;
440     napi_env env = (napi_env)engine_;
441     DealNapiStrValue(env, url.GetPassword(env), output);
442     ASSERT_STREQ(output.c_str(), "23aa");
443 }
444 
445 HWTEST_F(NativeEngineTest, testUrlPassword003, testing::ext::TestSize.Level0)
446 {
447     OHOS::Url::URL url("http://username@host:8080/directory/file?query#fragment");
448     std::string output;
449     napi_env env = (napi_env)engine_;
450     DealNapiStrValue(env, url.GetPassword(env), output);
451     ASSERT_STREQ(output.c_str(), "");
452 }
453 
454 HWTEST_F(NativeEngineTest, testUrlSetPassword001, testing::ext::TestSize.Level0)
455 {
456     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
457     std::string output;
458     napi_env env = (napi_env)engine_;
459     DealNapiStrValue(env, url.GetPassword(env), output);
460     ASSERT_STREQ(output.c_str(), "password");
461     url.SetPassword("666");
462     DealNapiStrValue(env, url.GetPassword(env), output);
463     ASSERT_STREQ(output.c_str(), "666");
464 }
465 
466 HWTEST_F(NativeEngineTest, testUrlSetPassword002, testing::ext::TestSize.Level0)
467 {
468     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
469     std::string output;
470     napi_env env = (napi_env)engine_;
471     DealNapiStrValue(env, url.GetPassword(env), output);
472     ASSERT_STREQ(output.c_str(), "password");
473     url.SetPassword("");
474     DealNapiStrValue(env, url.GetPassword(env), output);
475     ASSERT_STREQ(output.c_str(), "");
476 }
477 
478 HWTEST_F(NativeEngineTest, testUrlHost001, testing::ext::TestSize.Level0)
479 {
480     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
481     std::string output;
482     napi_env env = (napi_env)engine_;
483     DealNapiStrValue(env, url.GetHost(env), output);
484     ASSERT_STREQ(output.c_str(), "host:8080");
485 }
486 
487 HWTEST_F(NativeEngineTest, testUrlHost002, testing::ext::TestSize.Level0)
488 {
489     OHOS::Url::URL url("http://username:password@hosthost/directory/file?query#fragment");
490     std::string output;
491     napi_env env = (napi_env)engine_;
492     DealNapiStrValue(env, url.GetHost(env), output);
493     ASSERT_STREQ(output.c_str(), "hosthost");
494 }
495 
496 HWTEST_F(NativeEngineTest, testUrlHost003, testing::ext::TestSize.Level0)
497 {
498     OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment");
499     std::string output;
500     napi_env env = (napi_env)engine_;
501     DealNapiStrValue(env, url.GetHost(env), output);
502     ASSERT_STREQ(output.c_str(), "host:199");
503 }
504 
505 HWTEST_F(NativeEngineTest, testUrlSetHost001, testing::ext::TestSize.Level0)
506 {
507     OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment");
508     std::string output;
509     napi_env env = (napi_env)engine_;
510     DealNapiStrValue(env, url.GetHost(env), output);
511     ASSERT_STREQ(output.c_str(), "host:199");
512     url.SetHost("0.0.0.0.0:199");
513     DealNapiStrValue(env, url.GetHost(env), output);
514     ASSERT_STREQ(output.c_str(), "0.0.0.0.0:199");
515 }
516 
517 HWTEST_F(NativeEngineTest, testUrlSetHost002, testing::ext::TestSize.Level0)
518 {
519     OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment");
520     std::string output;
521     napi_env env = (napi_env)engine_;
522     DealNapiStrValue(env, url.GetHost(env), output);
523     ASSERT_STREQ(output.c_str(), "host:199");
524     url.SetHost("");
525     DealNapiStrValue(env, url.GetHost(env), output);
526     ASSERT_STREQ(output.c_str(), "host:199");
527 }
528 
529 HWTEST_F(NativeEngineTest, testUrlSetHref001, testing::ext::TestSize.Level0)
530 {
531     OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment");
532     std::string output;
533     napi_env env = (napi_env)engine_;
534     DealNapiStrValue(env, url.GetHost(env), output);
535     ASSERT_STREQ(output.c_str(), "host:199");
536     url.SetHref("http:huawei.com");
537     DealNapiStrValue(env, url.GetHost(env), output);
538     ASSERT_STREQ(output.c_str(), "huawei.com");
539 }
540 
541 HWTEST_F(NativeEngineTest, testUrlSetHref002, testing::ext::TestSize.Level0)
542 {
543     OHOS::Url::URL url("http://username:password@host:199/directory/file?query#fragment");
544     std::string output;
545     napi_env env = (napi_env)engine_;
546     DealNapiStrValue(env, url.GetHost(env), output);
547     ASSERT_STREQ(output.c_str(), "host:199");
548     url.SetHref("   http:huawei.com");
549     DealNapiStrValue(env, url.GetHost(env), output);
550     ASSERT_STREQ(output.c_str(), "huawei.com");
551 }
552 
553 HWTEST_F(NativeEngineTest, testUrlHostname001, testing::ext::TestSize.Level0)
554 {
555     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
556     std::string output;
557     napi_env env = (napi_env)engine_;
558     DealNapiStrValue(env, url.GetHostname(env), output);
559     ASSERT_STREQ(output.c_str(), "host");
560 }
561 
562 HWTEST_F(NativeEngineTest, testUrlHostname002, testing::ext::TestSize.Level0)
563 {
564     OHOS::Url::URL url("http://username:password@host123:8080/directory/file?query#fragment");
565     std::string output;
566     napi_env env = (napi_env)engine_;
567     DealNapiStrValue(env, url.GetHostname(env), output);
568     ASSERT_STREQ(output.c_str(), "host123");
569 }
570 
571 HWTEST_F(NativeEngineTest, testUrlHostname003, testing::ext::TestSize.Level0)
572 {
573     OHOS::Url::URL url("http://username:password@885ssa:8080/directory/file?query#fragment");
574     std::string output;
575     napi_env env = (napi_env)engine_;
576     DealNapiStrValue(env, url.GetHostname(env), output);
577     ASSERT_STREQ(output.c_str(), "885ssa");
578 }
579 
580 HWTEST_F(NativeEngineTest, testUrlPort001, testing::ext::TestSize.Level0)
581 {
582     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
583     std::string output;
584     napi_env env = (napi_env)engine_;
585     DealNapiStrValue(env, url.GetPort(env), output);
586     ASSERT_STREQ(output.c_str(), "8080");
587 }
588 
589 HWTEST_F(NativeEngineTest, testUrlPort002, testing::ext::TestSize.Level0)
590 {
591     OHOS::Url::URL url("http://username:password@host:100/directory/file?query#fragment");
592     std::string output;
593     napi_env env = (napi_env)engine_;
594     DealNapiStrValue(env, url.GetPort(env), output);
595     ASSERT_STREQ(output.c_str(), "100");
596 }
597 
598 
599 HWTEST_F(NativeEngineTest, testUrlPort003, testing::ext::TestSize.Level0)
600 {
601     OHOS::Url::URL url("http://username:password@host/directory/file?query#fragment");
602     std::string output;
603     napi_env env = (napi_env)engine_;
604     DealNapiStrValue(env, url.GetPort(env), output);
605     ASSERT_STREQ(output.c_str(), "");
606 }
607 
608 HWTEST_F(NativeEngineTest, testUrlSetPort001, testing::ext::TestSize.Level0)
609 {
610     OHOS::Url::URL url("http://username:password@host:100/directory/file?query#fragment");
611     std::string output;
612     napi_env env = (napi_env)engine_;
613     DealNapiStrValue(env, url.GetPort(env), output);
614     ASSERT_STREQ(output.c_str(), "100");
615     url.SetPort("600");
616     DealNapiStrValue(env, url.GetPort(env), output);
617     ASSERT_STREQ(output.c_str(), "600");
618 }
619 
620 HWTEST_F(NativeEngineTest, testUrlPathname001, testing::ext::TestSize.Level0)
621 {
622     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query#fragment");
623     std::string output;
624     napi_env env = (napi_env)engine_;
625     DealNapiStrValue(env, url.GetPath(env), output);
626     ASSERT_STREQ(output.c_str(), "/directory/file");
627 }
628 
629 HWTEST_F(NativeEngineTest, testUrlPathname002, testing::ext::TestSize.Level0)
630 {
631     OHOS::Url::URL url("http://username:password@host:8080/directory?query#fragment");
632     std::string output;
633     napi_env env = (napi_env)engine_;
634     DealNapiStrValue(env, url.GetPath(env), output);
635     ASSERT_STREQ(output.c_str(), "/directory");
636 }
637 
638 HWTEST_F(NativeEngineTest, testUrlPathname003, testing::ext::TestSize.Level0)
639 {
640     OHOS::Url::URL url("http://username:password@host:8080?query#fragment");
641     std::string output;
642     napi_env env = (napi_env)engine_;
643     DealNapiStrValue(env, url.GetPath(env), output);
644     ASSERT_STREQ(output.c_str(), "/");
645 }
646 
647 HWTEST_F(NativeEngineTest, testUrlSetPath001, testing::ext::TestSize.Level0)
648 {
649     OHOS::Url::URL url("http://username:password@host:8080?query#fragment");
650     std::string output;
651     napi_env env = (napi_env)engine_;
652     DealNapiStrValue(env, url.GetPath(env), output);
653     ASSERT_STREQ(output.c_str(), "/");
654     url.SetPath("\\D:");
655     DealNapiStrValue(env, url.GetPath(env), output);
656     ASSERT_STREQ(output.c_str(), "/D:");
657 }
658 
659 HWTEST_F(NativeEngineTest, testUrlSetPath002, testing::ext::TestSize.Level0)
660 {
661     OHOS::Url::URL url("http://username:password@host:8080?query#fragment");
662     std::string output;
663     napi_env env = (napi_env)engine_;
664     DealNapiStrValue(env, url.GetPath(env), output);
665     ASSERT_STREQ(output.c_str(), "/");
666     url.SetPath(":\\D:");
667     DealNapiStrValue(env, url.GetPath(env), output);
668     ASSERT_STREQ(output.c_str(), "/:/D:");
669 }
670 
671 HWTEST_F(NativeEngineTest, testUrlSetPath003, testing::ext::TestSize.Level0)
672 {
673     OHOS::Url::URL url("http://username:password@host:8080?query#fragment");
674     std::string output;
675     napi_env env = (napi_env)engine_;
676     DealNapiStrValue(env, url.GetPath(env), output);
677     ASSERT_STREQ(output.c_str(), "/");
678     url.SetPath("::");
679     DealNapiStrValue(env, url.GetPath(env), output);
680     ASSERT_STREQ(output.c_str(), "/::");
681 }
682 
683 HWTEST_F(NativeEngineTest, testUrlSearch001, testing::ext::TestSize.Level0)
684 {
685     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=qqqq#fragment");
686     std::string output;
687     napi_env env = (napi_env)engine_;
688     DealNapiStrValue(env, url.GetSearch(env), output);
689     ASSERT_STREQ(output.c_str(), "?query=qqqq");
690 }
691 
692 HWTEST_F(NativeEngineTest, testUrlSearch002, testing::ext::TestSize.Level0)
693 {
694     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=qqqq&ll=pp#fragment");
695     std::string output;
696     napi_env env = (napi_env)engine_;
697     DealNapiStrValue(env, url.GetSearch(env), output);
698     ASSERT_STREQ(output.c_str(), "?query=qqqq&ll=pp");
699 }
700 
701 HWTEST_F(NativeEngineTest, testUrlSearch003, testing::ext::TestSize.Level0)
702 {
703     OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment");
704     std::string output;
705     napi_env env = (napi_env)engine_;
706     DealNapiStrValue(env, url.GetSearch(env), output);
707     ASSERT_STREQ(output.c_str(), "?ppp9875=77");
708 }
709 
710 HWTEST_F(NativeEngineTest, testUrlSetSearch001, testing::ext::TestSize.Level0)
711 {
712     OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment");
713     std::string output;
714     napi_env env = (napi_env)engine_;
715     DealNapiStrValue(env, url.GetSearch(env), output);
716     ASSERT_STREQ(output.c_str(), "?ppp9875=77");
717     url.SetSearch("");
718     DealNapiStrValue(env, url.GetSearch(env), output);
719     ASSERT_STREQ(output.c_str(), "");
720 }
721 
722 HWTEST_F(NativeEngineTest, testUrlSetSearch002, testing::ext::TestSize.Level0)
723 {
724     OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment");
725     std::string output;
726     napi_env env = (napi_env)engine_;
727     DealNapiStrValue(env, url.GetSearch(env), output);
728     ASSERT_STREQ(output.c_str(), "?ppp9875=77");
729     url.SetSearch("?444=555");
730     DealNapiStrValue(env, url.GetSearch(env), output);
731     ASSERT_STREQ(output.c_str(), "?444=555");
732 }
733 
734 HWTEST_F(NativeEngineTest, testUrlSetSearch003, testing::ext::TestSize.Level0)
735 {
736     OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment");
737     std::string output;
738     napi_env env = (napi_env)engine_;
739     DealNapiStrValue(env, url.GetSearch(env), output);
740     ASSERT_STREQ(output.c_str(), "?ppp9875=77");
741     url.SetSearch("444=555");
742     DealNapiStrValue(env, url.GetSearch(env), output);
743     ASSERT_STREQ(output.c_str(), "?444=555");
744 }
745 
746 HWTEST_F(NativeEngineTest, testUrlSetSearch004, testing::ext::TestSize.Level0)
747 {
748     OHOS::Url::URL url("http://username:password@host:8080/directory/file?ppp9875=77#fragment");
749     std::string output;
750     napi_env env = (napi_env)engine_;
751     DealNapiStrValue(env, url.GetSearch(env), output);
752     ASSERT_STREQ(output.c_str(), "?ppp9875=77");
753     url.SetSearch("?##44=55");
754     DealNapiStrValue(env, url.GetSearch(env), output);
755     ASSERT_STREQ(output.c_str(), "?%23%2344=55");
756 }
757 
758 HWTEST_F(NativeEngineTest, testUrlGetFragment001, testing::ext::TestSize.Level0)
759 {
760     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#fragment");
761     std::string output;
762     napi_env env = (napi_env)engine_;
763     DealNapiStrValue(env, url.GetFragment(env), output);
764     ASSERT_STREQ(output.c_str(), "#fragment");
765 }
766 
767 HWTEST_F(NativeEngineTest, testUrlGetFragment002, testing::ext::TestSize.Level0)
768 {
769     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#fragment");
770     std::string output;
771     napi_env env = (napi_env)engine_;
772     DealNapiStrValue(env, url.GetFragment(env), output);
773     ASSERT_STREQ(output.c_str(), "#fragment");
774 }
775 
776 HWTEST_F(NativeEngineTest, testUrlGetFragment003, testing::ext::TestSize.Level0)
777 {
778     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456");
779     std::string output;
780     napi_env env = (napi_env)engine_;
781     DealNapiStrValue(env, url.GetFragment(env), output);
782     ASSERT_STREQ(output.c_str(), "#123456");
783 }
784 
785 HWTEST_F(NativeEngineTest, testUrlSetFragment001, testing::ext::TestSize.Level0)
786 {
787     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456");
788     std::string output;
789     napi_env env = (napi_env)engine_;
790     DealNapiStrValue(env, url.GetFragment(env), output);
791     ASSERT_STREQ(output.c_str(), "#123456");
792     url.SetFragment("");
793     DealNapiStrValue(env, url.GetFragment(env), output);
794     ASSERT_STREQ(output.c_str(), "");
795 }
796 
797 HWTEST_F(NativeEngineTest, testUrlSetFragment002, testing::ext::TestSize.Level0)
798 {
799     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456");
800     std::string output;
801     napi_env env = (napi_env)engine_;
802     DealNapiStrValue(env, url.GetFragment(env), output);
803     ASSERT_STREQ(output.c_str(), "#123456");
804     url.SetFragment("#445566");
805     DealNapiStrValue(env, url.GetFragment(env), output);
806     ASSERT_STREQ(output.c_str(), "#445566");
807 }
808 
809 HWTEST_F(NativeEngineTest, testUrlSetFragment003, testing::ext::TestSize.Level0)
810 {
811     OHOS::Url::URL url("http://username:password@host:8080/directory/file?query=pppppp#123456");
812     std::string output;
813     napi_env env = (napi_env)engine_;
814     DealNapiStrValue(env, url.GetFragment(env), output);
815     ASSERT_STREQ(output.c_str(), "#123456");
816     url.SetFragment("445566");
817     DealNapiStrValue(env, url.GetFragment(env), output);
818     ASSERT_STREQ(output.c_str(), "#445566");
819 }
820 
821 HWTEST_F(NativeEngineTest, testUrlIPV6001, testing::ext::TestSize.Level0)
822 {
823     OHOS::Url::URL url("http://[1080:0:0:0:8:800:200C:417A]/index.html");
824     napi_env env = (napi_env)engine_;
825     napi_value result = url.GetIsIpv6(env);
826     bool value = false;
827     napi_get_value_bool(env, result, &value);
828     ASSERT_TRUE(value);
829 }
830 
831 HWTEST_F(NativeEngineTest, testUrlIPV6002, testing::ext::TestSize.Level0)
832 {
833     OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html");
834     napi_env env = (napi_env)engine_;
835     napi_value result = url.GetIsIpv6(env);
836     bool value = false;
837     napi_get_value_bool(env, result, &value);
838     ASSERT_FALSE(value);
839 }
840 
841 HWTEST_F(NativeEngineTest, testUrlIPV6003, testing::ext::TestSize.Level0)
842 {
843     OHOS::Url::URL url("http://[1080:0:0:0:8:800:200C.417A]/index.html");
844     napi_env env = (napi_env)engine_;
845     napi_value result = url.GetIsIpv6(env);
846     bool value = false;
847     napi_get_value_bool(env, result, &value);
848     ASSERT_FALSE(value);
849 }
850 
851 HWTEST_F(NativeEngineTest, testUrlGetOnOrOff001, testing::ext::TestSize.Level0)
852 {
853     OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html");
854     napi_env env = (napi_env)engine_;
855     napi_value result = url.GetOnOrOff(env);
856     bool value = false;
857     napi_get_value_bool(env, result, &value);
858     ASSERT_TRUE(value);
859 }
860 
861 HWTEST_F(NativeEngineTest, testUrlSetHostname001, testing::ext::TestSize.Level0)
862 {
863     OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html");
864     napi_env env = (napi_env)engine_;
865     std::string output;
866     std::string value = "host";
867     url.SetHostname(value);
868     DealNapiStrValue(env, url.GetHostname(env), output);
869     ASSERT_STREQ(output.c_str(), "host");
870 }
871 
872 HWTEST_F(NativeEngineTest, testUrlSetHostname002, testing::ext::TestSize.Level0)
873 {
874     OHOS::Url::URL url("http://0377.0xff.255.1:80/index.html");
875     napi_env env = (napi_env)engine_;
876     std::string output;
877     std::string value = "";
878     url.SetHostname(value);
879     DealNapiStrValue(env, url.GetHostname(env), output);
880     ASSERT_STREQ(output.c_str(), "255.255.255.1");
881 }
882 
883 HWTEST_F(NativeEngineTest, testUrlSearchParams001, testing::ext::TestSize.Level0)
884 {
885     OHOS::Url::URL url("http://username:password@host:8080/directory/file?foo=1&bar=2");
886     std::string output;
887     napi_env env = (napi_env)engine_;
888     DealNapiStrValue(env, url.GetSearch(env), output);
889     ASSERT_STREQ(output.c_str(), "?foo=1&bar=2");
890 }
891 
892 HWTEST_F(NativeEngineTest, testUrlSearchParams002, testing::ext::TestSize.Level0)
893 {
894     OHOS::Url::URL url("https://example.com?d=value1&c=value2&b=大&4=key4");
895     std::string output;
896     napi_env env = (napi_env)engine_;
897     DealNapiStrValue(env, url.GetSearch(env), output);
898     ASSERT_STREQ(output.c_str(), "?d=value1&c=value2&b=大&4=key4");
899 }
900 
901 HWTEST_F(NativeEngineTest, testUrlSearchParams003, testing::ext::TestSize.Level0)
902 {
903     OHOS::Url::URL url("http://username:password@host:8080/directory/file?你好=china#qwer=da");
904     std::string output;
905     napi_env env = (napi_env)engine_;
906     DealNapiStrValue(env, url.GetSearch(env), output);
907     ASSERT_STREQ(output.c_str(), "?你好=china");
908 }
909 
910 HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend001, testing::ext::TestSize.Level0)
911 {
912     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
913     std::string output;
914     napi_env env = (napi_env)engine_;
915     napi_value input1 = StrToNapiValue(env, "ma");
916     napi_value input2 = StrToNapiValue(env, "jk");
917     params.Append(env, input1, input2);
918     napi_value tempValue = params.GetArray(env);
919     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
920     DealNapiStrValue(env, ToString(env, paramsString), output);
921     ASSERT_STREQ(output.c_str(), "ma=jk");
922 }
923 
924 HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend002, testing::ext::TestSize.Level0)
925 {
926     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
927     std::string output;
928     napi_env env = (napi_env)engine_;
929     napi_value input1 = StrToNapiValue(env, "ma 大");
930     napi_value input2 = StrToNapiValue(env, "jk￥");
931     params.Append(env, input1, input2);
932     napi_value tempValue = params.GetArray(env);
933     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
934     DealNapiStrValue(env, ToString(env, paramsString), output);
935     ASSERT_STREQ(output.c_str(), "ma+%E5%A4%A7=jk%EF%BF%A5");
936 }
937 
938 HWTEST_F(NativeEngineTest, testUrlSearchParamsAppend003, testing::ext::TestSize.Level0)
939 {
940     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
941     std::string output;
942     napi_env env = (napi_env)engine_;
943     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
944     napi_value input2 = StrToNapiValue(env, "jk");
945     params.Append(env, input1, input2);
946     napi_value tempValue = params.GetArray(env);
947     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
948     DealNapiStrValue(env, ToString(env, paramsString), output);
949     ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk");
950 }
951 
952 HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete001, testing::ext::TestSize.Level0)
953 {
954     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
955     std::string output;
956     napi_env env = (napi_env)engine_;
957     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
958     napi_value input2 = StrToNapiValue(env, "jk");
959     params.Append(env, input1, input2);
960     params.Delete(env, input1);
961     napi_value tempValue = params.GetArray(env);
962     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
963     DealNapiStrValue(env, ToString(env, paramsString), output);
964     ASSERT_STREQ(output.c_str(), "");
965 }
966 
967 HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete002, testing::ext::TestSize.Level0)
968 {
969     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
970     std::string output;
971     napi_env env = (napi_env)engine_;
972     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
973     napi_value input2 = StrToNapiValue(env, "jk");
974     params.Append(env, input1, input2);
975     napi_value input3 = StrToNapiValue(env, "ma");
976     napi_value input4 = StrToNapiValue(env, "jk");
977     params.Append(env, input3, input4);
978     params.Delete(env, input1);
979     napi_value tempValue = params.GetArray(env);
980     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
981     DealNapiStrValue(env, ToString(env, paramsString), output);
982     ASSERT_STREQ(output.c_str(), "ma=jk");
983 }
984 
985 HWTEST_F(NativeEngineTest, testUrlSearchParamsDelete003, testing::ext::TestSize.Level0)
986 {
987     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
988     std::string output;
989     napi_env env = (napi_env)engine_;
990     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
991     napi_value input2 = StrToNapiValue(env, "jk");
992     params.Append(env, input1, input2);
993     napi_value input3 = StrToNapiValue(env, "ma");
994     napi_value input4 = StrToNapiValue(env, "jk");
995     params.Append(env, input3, input4);
996     params.Delete(env, input1);
997     params.Delete(env, input3);
998     napi_value tempValue = params.GetArray(env);
999     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1000     DealNapiStrValue(env, ToString(env, paramsString), output);
1001     ASSERT_STREQ(output.c_str(), "");
1002 }
1003 
1004 HWTEST_F(NativeEngineTest, testUrlSearchParamsGet001, testing::ext::TestSize.Level0)
1005 {
1006     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1007     std::string output;
1008     napi_env env = (napi_env)engine_;
1009     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1010     napi_value input2 = StrToNapiValue(env, "jk");
1011     params.Append(env, input1, input2);
1012     DealNapiStrValue(env, params.Get(env, input1), output);
1013     ASSERT_STREQ(output.c_str(), "jk");
1014 }
1015 
1016 HWTEST_F(NativeEngineTest, testUrlSearchParamsGet002, testing::ext::TestSize.Level0)
1017 {
1018     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1019     std::string output;
1020     napi_env env = (napi_env)engine_;
1021     napi_value input1 = StrToNapiValue(env, "jk");
1022     DealNapiStrValue(env, params.Get(env, input1), output);
1023     ASSERT_STREQ(output.c_str(), "");
1024 }
1025 
1026 HWTEST_F(NativeEngineTest, testUrlSearchParamsGet003, testing::ext::TestSize.Level0)
1027 {
1028     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1029     std::string output;
1030     napi_env env = (napi_env)engine_;
1031     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1032     napi_value input2 = StrToNapiValue(env, "jk");
1033     params.Append(env, input1, input2);
1034     DealNapiStrValue(env, params.Get(env, input1), output);
1035     ASSERT_STREQ(output.c_str(), "jk");
1036 }
1037 
1038 HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll001, testing::ext::TestSize.Level0)
1039 {
1040     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1041     std::string output;
1042     napi_env env = (napi_env)engine_;
1043     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1044     napi_value input2 = StrToNapiValue(env, "jk");
1045     params.Append(env, input1, input2);
1046     napi_value input3 = StrToNapiValue(env, "jk");
1047     DealNapiStrValue(env, params.GetAll(env, input3), output);
1048     ASSERT_STREQ(output.c_str(), "");
1049 }
1050 
1051 HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll002, testing::ext::TestSize.Level0)
1052 {
1053     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1054     std::string output;
1055     napi_env env = (napi_env)engine_;
1056     napi_value input1 = StrToNapiValue(env, "ma");
1057     napi_value input2 = StrToNapiValue(env, "jk");
1058     params.Append(env, input1, input2);
1059     napi_value input3 = StrToNapiValue(env, "jk1");
1060     DealNapiStrValue(env, params.GetAll(env, input3), output);
1061     ASSERT_STREQ(output.c_str(), "");
1062 }
1063 
1064 HWTEST_F(NativeEngineTest, testUrlSearchParamsGetAll003, testing::ext::TestSize.Level0)
1065 {
1066     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1067     std::string output;
1068     napi_env env = (napi_env)engine_;
1069     napi_value input1 = StrToNapiValue(env, "#[%@]");
1070     napi_value input2 = StrToNapiValue(env, "jk");
1071     params.Append(env, input1, input2);
1072     napi_value input3 = StrToNapiValue(env, "ma1");
1073     napi_value input4 = StrToNapiValue(env, "jk1");
1074     params.Append(env, input3, input4);
1075     napi_value input5 = StrToNapiValue(env, "jk2");
1076     DealNapiStrValue(env, params.GetAll(env, input5), output);
1077     ASSERT_STREQ(output.c_str(), "");
1078 }
1079 
1080 HWTEST_F(NativeEngineTest, testUrlSearchParamsToUSVString001, testing::ext::TestSize.Level0)
1081 {
1082     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1083     std::string output;
1084     napi_env env = (napi_env)engine_;
1085     napi_value input1 = StrToNapiValue(env, "你好");
1086     napi_value input2 = StrToNapiValue(env, "안녕하세요");
1087     params.Append(env, input1, input2);
1088     napi_value input3 = StrToNapiValue(env, "[saa]");
1089     napi_value input4 = StrToNapiValue(env, "{aas}");
1090     params.Append(env, input3, input4);
1091     napi_value input5 = StrToNapiValue(env, "你好");
1092     DealNapiStrValue(env, params.Get(env, input5), output);
1093     ASSERT_STREQ(output.c_str(), "안녕하세요");
1094 }
1095 
1096 HWTEST_F(NativeEngineTest, testUrlSearchParamsHas001, testing::ext::TestSize.Level0)
1097 {
1098     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1099     std::string output;
1100     napi_env env = (napi_env)engine_;
1101     napi_value input1 = StrToNapiValue(env, "ma");
1102     DealNapiStrValue(env, params.IsHas(env, input1), output);
1103     ASSERT_STREQ(output.c_str(), "");
1104 }
1105 
1106 HWTEST_F(NativeEngineTest, testUrlSearchParamsHas002, testing::ext::TestSize.Level0)
1107 {
1108     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1109     std::string output;
1110     napi_env env = (napi_env)engine_;
1111     napi_value input1 = StrToNapiValue(env, "ma");
1112     napi_value input2 = StrToNapiValue(env, "jk");
1113     params.Append(env, input1, input2);
1114     napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1115     napi_value input4 = StrToNapiValue(env, "jk1");
1116     params.Append(env, input3, input4);
1117     DealNapiStrValue(env, params.IsHas(env, input1), output);
1118     ASSERT_STREQ(output.c_str(), "");
1119 }
1120 
1121 HWTEST_F(NativeEngineTest, testUrlSearchParamsHas003, 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 input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1130     napi_value input4 = StrToNapiValue(env, "jk1");
1131     params.Append(env, input3, input4);
1132     DealNapiStrValue(env, params.IsHas(env, input3), output);
1133     ASSERT_STREQ(output.c_str(), "");
1134 }
1135 
1136 HWTEST_F(NativeEngineTest, testUrlSearchParamsSet001, testing::ext::TestSize.Level0)
1137 {
1138     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1139     std::string output;
1140     napi_env env = (napi_env)engine_;
1141     napi_value input1 = StrToNapiValue(env, "ma");
1142     napi_value input2 = StrToNapiValue(env, "jk");
1143     params.Append(env, input1, input2);
1144     napi_value input3 = StrToNapiValue(env, "aa");
1145     params.Set(env, input1, input3);
1146     napi_value tempValue = params.GetArray(env);
1147     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1148     DealNapiStrValue(env, ToString(env, paramsString), output);
1149     ASSERT_STREQ(output.c_str(), "ma=aa");
1150 }
1151 
1152 HWTEST_F(NativeEngineTest, testUrlSearchParamsSet002, testing::ext::TestSize.Level0)
1153 {
1154     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1155     std::string output;
1156     napi_env env = (napi_env)engine_;
1157     napi_value input1 = StrToNapiValue(env, "ma1");
1158     napi_value input2 = StrToNapiValue(env, "aa");
1159     params.Append(env, input1, input2);
1160     params.Set(env, input1, input2);
1161     napi_value tempValue = params.GetArray(env);
1162     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1163     DealNapiStrValue(env, ToString(env, paramsString), output);
1164     ASSERT_STREQ(output.c_str(), "ma1=aa");
1165 }
1166 
1167 HWTEST_F(NativeEngineTest, testUrlSearchParamsSet003, testing::ext::TestSize.Level0)
1168 {
1169     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1170     std::string output;
1171     napi_env env = (napi_env)engine_;
1172     napi_value input1 = StrToNapiValue(env, "ma");
1173     napi_value input2 = StrToNapiValue(env, "jk");
1174     params.Append(env, input1, input2);
1175     napi_value input3 = StrToNapiValue(env, "ma1");
1176     napi_value input4 = StrToNapiValue(env, "aa");
1177     params.Set(env, input3, input4);
1178     napi_value tempValue = params.GetArray(env);
1179     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1180     DealNapiStrValue(env, ToString(env, paramsString), output);
1181     ASSERT_STREQ(output.c_str(), "ma=jk&ma1=aa");
1182 }
1183 
1184 HWTEST_F(NativeEngineTest, testUrlSearchParamsSort001, testing::ext::TestSize.Level0)
1185 {
1186     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1187     std::string output;
1188     napi_env env = (napi_env)engine_;
1189     napi_value input1 = StrToNapiValue(env, "ma");
1190     napi_value input2 = StrToNapiValue(env, "jk");
1191     params.Append(env, input1, input2);
1192     napi_value input3 = StrToNapiValue(env, "a");
1193     napi_value input4 = StrToNapiValue(env, "jk1");
1194     params.Append(env, input3, input4);
1195     params.Sort();
1196     napi_value tempValue = params.GetArray(env);
1197     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1198     DealNapiStrValue(env, ToString(env, paramsString), output);
1199     ASSERT_STREQ(output.c_str(), "a=jk1&ma=jk");
1200 }
1201 
1202 HWTEST_F(NativeEngineTest, testUrlSearchParamsSort002, testing::ext::TestSize.Level0)
1203 {
1204     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1205     std::string output;
1206     napi_env env = (napi_env)engine_;
1207     napi_value input1 = StrToNapiValue(env, "ma");
1208     napi_value input2 = StrToNapiValue(env, "jk");
1209     params.Append(env, input1, input2);
1210     napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1211     napi_value input4 = StrToNapiValue(env, "jk1");
1212     params.Append(env, input3, input4);
1213     params.Sort();
1214     napi_value tempValue = params.GetArray(env);
1215     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1216     DealNapiStrValue(env, ToString(env, paramsString), output);
1217     ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk1&ma=jk");
1218 }
1219 
1220 HWTEST_F(NativeEngineTest, testUrlSearchParamsSort003, testing::ext::TestSize.Level0)
1221 {
1222     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1223     std::string output;
1224     napi_env env = (napi_env)engine_;
1225     napi_value input1 = StrToNapiValue(env, "ma");
1226     napi_value input2 = StrToNapiValue(env, "jk");
1227     params.Append(env, input1, input2);
1228     napi_value input3 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1229     napi_value input4 = StrToNapiValue(env, "jk1");
1230     params.Append(env, input3, input4);
1231     napi_value input5 = StrToNapiValue(env, "a");
1232     napi_value input6 = StrToNapiValue(env, "jk2");
1233     params.Append(env, input5, input6);
1234     params.Sort();
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(), "a=jk2&foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk1&ma=jk");
1239 }
1240 
1241 HWTEST_F(NativeEngineTest, testUrlSearchParamsToString001, 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, "1 12");
1247     napi_value input2 = StrToNapiValue(env, "jk");
1248     params.Append(env, input1, input2);
1249     napi_value tempValue = params.GetArray(env);
1250     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1251     DealNapiStrValue(env, ToString(env, paramsString), output);
1252     ASSERT_STREQ(output.c_str(), "1+12=jk");
1253 }
1254 
1255 HWTEST_F(NativeEngineTest, testUrlSearchParamsToString002, testing::ext::TestSize.Level0)
1256 {
1257     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1258     std::string output;
1259     napi_env env = (napi_env)engine_;
1260     napi_value input1 = StrToNapiValue(env, "￥=)");
1261     napi_value input2 = StrToNapiValue(env, "jk");
1262     params.Append(env, input1, input2);
1263     napi_value tempValue = params.GetArray(env);
1264     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1265     DealNapiStrValue(env, ToString(env, paramsString), output);
1266     ASSERT_STREQ(output.c_str(), "%EF%BF%A5%3D%29=jk");
1267 }
1268 
1269 HWTEST_F(NativeEngineTest, testUrlSearchParamsToString003, testing::ext::TestSize.Level0)
1270 {
1271     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1272     std::string output;
1273     napi_env env = (napi_env)engine_;
1274     napi_value input1 = StrToNapiValue(env, "foo~!@#$%^&*()_+-=");
1275     napi_value input2 = StrToNapiValue(env, "jk");
1276     params.Append(env, input1, input2);
1277     napi_value tempValue = params.GetArray(env);
1278     std::vector<std::string> paramsString = GetParamsStrig(env, tempValue);
1279     DealNapiStrValue(env, ToString(env, paramsString), output);
1280     ASSERT_STREQ(output.c_str(), "foo%7E%21%40%23%24%25%5E%26*%28%29_%2B-%3D=jk");
1281 }
1282 
1283 HWTEST_F(NativeEngineTest, testUrlSearchParams, testing::ext::TestSize.Level0)
1284 {
1285     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1286     std::string output;
1287     napi_env env = (napi_env)engine_;
1288     napi_value input1 = StrToNapiValue(env, "ma");
1289     DealNapiStrValue(env, params.IsHas(env, input1), output);
1290     ASSERT_STREQ(output.c_str(), "");
1291 }
1292 
1293 HWTEST_F(NativeEngineTest, testUrlSearchParamsSetArray, testing::ext::TestSize.Level0)
1294 {
1295     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1296     std::string input1 = "jk";
1297     std::string input2 = "ma";
1298     napi_env env = (napi_env)engine_;
1299     std::vector<std::string> vec;
1300     vec.push_back(input1);
1301     vec.push_back(input2);
1302     params.SetArray(env, vec);
1303     napi_value result = params.GetArray(env);
1304     uint32_t length = 0;
1305     napi_value napiStr = nullptr;
1306     size_t arraySize = 0;
1307     napi_get_array_length(env, result, &length);
1308     std::string cstr1 = "";
1309     for (size_t i = 0; i < length; i++) {
1310         napi_get_element(env, result, i, &napiStr);
1311         napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize);
1312         if (arraySize > 0) {
1313             napi_get_value_string_utf8(env, napiStr, cstr1.data(), arraySize + 1, &arraySize);
1314         }
1315         if (i == 0) {
1316             ASSERT_STREQ("jk", cstr1.data());
1317         } else {
1318             ASSERT_STREQ(cstr1.data(), "ma");
1319         }
1320     }
1321 }
1322 
1323 HWTEST_F(NativeEngineTest, testUrlSearchParamsIterByKeys, testing::ext::TestSize.Level0)
1324 {
1325     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1326     std::string input1 = "jk";
1327     std::string input2 = "ma";
1328     napi_env env = (napi_env)engine_;
1329     std::vector<std::string> vec;
1330     vec.push_back(input1);
1331     vec.push_back(input2);
1332     params.SetArray(env, vec);
1333     napi_value result = params.IterByKeys(env);
1334     uint32_t length = 0;
1335     napi_value napiStr = nullptr;
1336     size_t arraySize = 0;
1337     napi_get_array_length(env, result, &length);
1338     std::string cstr = "";
1339     for (size_t i = 0; i < length; i += 2) {
1340         napi_get_element(env, result, i, &napiStr);
1341         napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize);
1342         if (arraySize > 0) {
1343             napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize);
1344         }
1345     }
1346     ASSERT_STREQ(cstr.data(), "jk");
1347 }
1348 
1349 HWTEST_F(NativeEngineTest, testUrlSearchParamsIterByValues, testing::ext::TestSize.Level0)
1350 {
1351     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1352     std::string input1 = "jk";
1353     std::string input2 = "ma";
1354     napi_env env = (napi_env)engine_;
1355     std::vector<std::string> vec;
1356     vec.push_back(input1);
1357     vec.push_back(input2);
1358     params.SetArray(env, vec);
1359     napi_value result = params.IterByValues(env);
1360     uint32_t length = 0;
1361     napi_value napiStr = nullptr;
1362     size_t arraySize = 0;
1363     napi_get_array_length(env, result, &length);
1364     std::string cstr = "";
1365     for (size_t i = 0; i < length; i++) {
1366         napi_get_element(env, result, i, &napiStr);
1367         napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize);
1368         if (arraySize > 0) {
1369             napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize);
1370         }
1371     }
1372     ASSERT_STREQ(cstr.data(), "ma");
1373 }
1374 
1375 HWTEST_F(NativeEngineTest, testUrlSearchParamsEntries001, testing::ext::TestSize.Level0)
1376 {
1377     OHOS::Url::URLSearchParams params = OHOS::Url::URLSearchParams();
1378     napi_env env = (napi_env)engine_;
1379     napi_value input1 = StrToNapiValue(env, "ma");
1380     napi_value input2 = StrToNapiValue(env, "jk");
1381     params.Append(env, input1, input2);
1382     napi_value input3 = StrToNapiValue(env, "你好");
1383     napi_value input4 = StrToNapiValue(env, "jk1");
1384     params.Append(env, input3, input4);
1385     napi_value input5 = StrToNapiValue(env, "a");
1386     napi_value input6 = StrToNapiValue(env, "jk2");
1387     params.Append(env, input5, input6);
1388     napi_value result = params.Entries(env);
1389     uint32_t length = 0;
1390     napi_value napiStr = nullptr;
1391     size_t arraySize = 0;
1392     napi_get_array_length(env, result, &length);
1393     std::string cstr = "";
1394     for (size_t i = 0; i < length; i++) {
1395         napi_get_element(env, result, i, &napiStr);
1396         napi_get_value_string_utf8(env, napiStr, nullptr, 0, &arraySize);
1397         if (arraySize > 0) {
1398             napi_get_value_string_utf8(env, napiStr, cstr.data(), arraySize + 1, &arraySize);
1399         }
1400     }
1401     ASSERT_EQ(length, 3);
1402 }