1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18 #include <securec.h>
19
20 #define private public
21 #include "nweb.h"
22 #include "nweb_helper.h"
23 #include "nweb_config_helper.h"
24 #include "nweb_adapter_helper.h"
25 #include "base/web/webview/interfaces/native/arkweb_scheme_handler.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace {
32 const std::string BUNDLE_PATH = "/data/app/el1/bundle/public/com.ohos.arkwebcore";
33 } // namespace
34
35 namespace NWeb {
36
37 class OHArkwebSchemeHandlerTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void OHArkwebSchemeHandlerTest::SetUpTestCase(void)
46 {}
47
TearDownTestCase(void)48 void OHArkwebSchemeHandlerTest::TearDownTestCase(void)
49 {}
50
SetUp(void)51 void OHArkwebSchemeHandlerTest::SetUp(void)
52 {}
53
TearDown(void)54 void OHArkwebSchemeHandlerTest::TearDown(void)
55 {}
56
57
58 /**
59 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_001
60 * @tc.desc : g_SchemeHandlerApi is nullptr
61 */
62 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_001, TestSize.Level1) {
63 ArkWeb_RequestHeaderList* headerList = nullptr;
64 OH_ArkWebRequestHeaderList_Destroy(headerList);
65 int32_t ret = OH_ArkWebRequestHeaderList_GetSize(headerList);
66 EXPECT_EQ(ret, -1);
67
68 int32_t index = 0;
69 char* key = nullptr;
70 char* value = nullptr;
71 OH_ArkWebRequestHeaderList_GetHeader(headerList, index, &key, &value);
72
73 ArkWeb_ResourceRequest* resourceRequest = nullptr;
74 char* method = nullptr;
75 OH_ArkWebResourceRequest_GetMethod(resourceRequest, &method);
76
77 char* url = nullptr;
78 OH_ArkWebResourceRequest_GetUrl(resourceRequest, &url);
79
80 ArkWeb_HttpBodyStream* httpBodyStream = nullptr;
81 OH_ArkWebResourceRequest_GetHttpBodyStream(resourceRequest, &httpBodyStream);
82 OH_ArkWebResourceRequest_DestroyHttpBodyStream(httpBodyStream);
83
84 ret = OH_ArkWebResourceRequest_GetResourceType(resourceRequest);
85 EXPECT_EQ(ret, -1);
86
87 char* frameUrl = nullptr;
88 OH_ArkWebResourceRequest_GetFrameUrl(resourceRequest, &frameUrl);
89
90 void* userData = nullptr;
91 int32_t result = OH_ArkWebHttpBodyStream_SetUserData(httpBodyStream, userData);
92 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
93
94 void* userDataGet = OH_ArkWebHttpBodyStream_GetUserData(httpBodyStream);
95 EXPECT_EQ(userDataGet, nullptr);
96 }
97
98 /**
99 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_002
100 * @tc.desc : g_SchemeHandlerApi is nullptr
101 */
102 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_002, TestSize.Level1) {
103 ArkWeb_HttpBodyStream* httpBodyStream = nullptr;
104 ArkWeb_HttpBodyStreamReadCallback readCallback = nullptr;
105 int32_t result = OH_ArkWebHttpBodyStream_SetReadCallback(httpBodyStream, readCallback);
106 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
107
108 ArkWeb_HttpBodyStreamInitCallback initCallback = nullptr;
109 result = OH_ArkWebHttpBodyStream_Init(httpBodyStream, initCallback);
110 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
111
112 const ArkWeb_HttpBodyStream* httpBodyStream1 = nullptr;
113 uint8_t buffer[256] = {0};
114 int bufLen = sizeof(buffer);
115 OH_ArkWebHttpBodyStream_Read(httpBodyStream1, buffer, bufLen);
116
117 uint64_t size = OH_ArkWebHttpBodyStream_GetSize(httpBodyStream1);
118 EXPECT_EQ(size, 0);
119 uint64_t position = OH_ArkWebHttpBodyStream_GetPosition(httpBodyStream1);
120 EXPECT_EQ(position, 0);
121 bool boolResult = OH_ArkWebHttpBodyStream_IsChunked(httpBodyStream);
122 EXPECT_FALSE(boolResult);
123 boolResult = OH_ArkWebHttpBodyStream_IsEof(httpBodyStream);
124 EXPECT_FALSE(boolResult);
125 boolResult = OH_ArkWebHttpBodyStream_IsInMemory(httpBodyStream);
126 EXPECT_FALSE(boolResult);
127
128 const ArkWeb_ResourceRequest* resourceRequest = nullptr;
129 result = OH_ArkWebResourceRequest_Destroy(resourceRequest);
130 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
131 char* referrer = nullptr;
132 OH_ArkWebResourceRequest_GetReferrer(resourceRequest, &referrer);
133 }
134
135 /**
136 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_003
137 * @tc.desc : g_SchemeHandlerApi is nullptr
138 */
139 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_003, TestSize.Level1) {
140 ArkWeb_ResourceRequest* resourceRequest = nullptr;
141 void* userData = nullptr;
142 int32_t result = OH_ArkWebResourceRequest_SetUserData(resourceRequest, userData);
143 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
144
145 const ArkWeb_ResourceRequest* resourceRequest1 = nullptr;
146 void* userData1 = OH_ArkWebResourceRequest_GetUserData(resourceRequest1);
147 EXPECT_EQ(userData1, nullptr);
148
149 ArkWeb_RequestHeaderList* requestHeaderList = nullptr;
150 OH_ArkWebResourceRequest_GetRequestHeaders(resourceRequest1, &requestHeaderList);
151 EXPECT_EQ(requestHeaderList, nullptr);
152
153 bool boolResult = OH_ArkWebResourceRequest_IsRedirect(resourceRequest1);
154 EXPECT_EQ(boolResult, false);
155 boolResult = OH_ArkWebResourceRequest_IsMainFrame(resourceRequest1);
156 EXPECT_EQ(boolResult, false);
157 boolResult = OH_ArkWebResourceRequest_HasGesture(resourceRequest);
158 EXPECT_EQ(boolResult, false);
159
160 const char* webTag = nullptr;
161 result = OH_ArkWeb_ClearSchemeHandlers(webTag);
162 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
163 result = OH_ArkWebServiceWorker_ClearSchemeHandlers();
164 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
165 ArkWeb_SchemeHandler* schemeHandler = nullptr;
166 OH_ArkWeb_DestroySchemeHandler(schemeHandler);
167
168 result = OH_ArkWebSchemeHandler_SetUserData(schemeHandler, userData);
169 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
170
171 const ArkWeb_SchemeHandler* schemeHandler1 = nullptr;
172 void* userData2 = OH_ArkWebSchemeHandler_GetUserData(schemeHandler1);
173 EXPECT_EQ(userData2, nullptr);
174 }
175
176 /**
177 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_004
178 * @tc.desc : g_SchemeHandlerApi is nullptr
179 */
180 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_004, TestSize.Level1) {
181 ArkWeb_SchemeHandler* schemeHandler = nullptr;
182 ArkWeb_OnRequestStart onRequestStart = nullptr;
183 int32_t result = OH_ArkWebSchemeHandler_SetOnRequestStart(schemeHandler, onRequestStart);
184 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
185 ArkWeb_OnRequestStop onRequestStop = nullptr;
186 result = OH_ArkWebSchemeHandler_SetOnRequestStop(schemeHandler, onRequestStop);
187 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
188 ArkWeb_Response* response = nullptr;
189 OH_ArkWeb_DestroyResponse(response);
190 const char* url = "www.example.com";
191 result = OH_ArkWebResponse_SetUrl(response, url);
192 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
193 char* url1 = nullptr;
194 OH_ArkWebResponse_GetUrl(response, &url1);
195
196 ArkWeb_NetError errorCode = ARKWEB_NET_OK;
197 result = OH_ArkWebResponse_SetError(response, errorCode);
198 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
199 ArkWeb_NetError errorCodeRes = OH_ArkWebResponse_GetError(response);
200 EXPECT_EQ(errorCodeRes, ARKWEB_ERR_FAILED);
201 int status = -1;
202 result = OH_ArkWebResponse_SetStatus(response, status);
203 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
204 int statusRes = OH_ArkWebResponse_GetStatus(response);
205 EXPECT_EQ(statusRes, -1);
206
207 const char* statusText = "Test Status Text";
208 result = OH_ArkWebResponse_SetStatusText(response, statusText);
209 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
210 char* statusTextGet = nullptr;
211 OH_ArkWebResponse_GetStatusText(response, &statusTextGet);
212
213 const char* mimeType = "text/plain";
214 result = OH_ArkWebResponse_SetMimeType(response, mimeType);
215 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
216 char* mimeTypeRes = nullptr;
217 OH_ArkWebResponse_GetMimeType(response, &mimeTypeRes);
218 const char* charSet = "";
219 result = OH_ArkWebResponse_SetCharset(response, charSet);
220 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
221 char* charSetRes = nullptr;
222 OH_ArkWebResponse_GetCharset(response, &charSetRes);
223 const char* name = "TestHeaderName";
224 const char* value = "TestHeaderValue";
225 result = OH_ArkWebResponse_SetHeaderByName(response, name, value, true);
226 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
227 char* valueRes = nullptr;
228 OH_ArkWebResponse_GetHeaderByName(response, name, &valueRes);
229 }
230
231 /**
232 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_005
233 * @tc.desc : g_SchemeHandlerApi is nullptr
234 */
235 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNull_005, TestSize.Level1) {
236 ArkWeb_ResourceHandler* resourceHandler = nullptr;
237 int32_t res = OH_ArkWebResourceHandler_Destroy(resourceHandler);
238 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
239
240 ArkWeb_Response* response;
241 res = OH_ArkWebResourceHandler_DidReceiveResponse(resourceHandler, response);
242 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
243
244 const uint8_t* buffer = reinterpret_cast<const uint8_t*>("TestBuffer");
245 int64_t bufLen = strlen("TestBuffer");
246 res = OH_ArkWebResourceHandler_DidReceiveData(nullptr, buffer, bufLen);
247 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
248 res = OH_ArkWebResourceHandler_DidFinish(nullptr);
249 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
250
251 ArkWeb_NetError errorCode = ARKWEB_NET_OK;
252 res = OH_ArkWebResourceHandler_DidFailWithError(resourceHandler, errorCode);
253 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
254 char* str = nullptr;
255 OH_ArkWeb_ReleaseString(str);
256 uint8_t byteArray[10] = {0};
257 OH_ArkWeb_ReleaseByteArray(byteArray);
258 ArkWeb_SchemeHandler* schemeHandler = nullptr;
259 res = OH_ArkWebSchemeHandler_SetFromEts(schemeHandler, true);
260 EXPECT_EQ(res, ARKWEB_ERROR_UNKNOWN);
261 }
262
263 /**
264 * @tc.name : OHArkwebSchemeHandlerTest_WebEngineHandleIsNull_004
265 * @tc.desc : webEngineHandle is nullptr and g_SchemeHandlerApi is nullptr
266 */
267 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_WebEngineHandleIsNull_004, TestSize.Level1) {
268 NWebHelper::Instance().bundlePath_ = "";
269 const char* scheme = "scheme";
270 int32_t option = 0;
271 const char* webTag = "webTag";
272 ArkWeb_SchemeHandler* schemeHandler = nullptr;
273
274 int32_t result = OH_ArkWeb_RegisterCustomSchemes(scheme, option);
275 EXPECT_EQ(result, ARKWEB_ERROR_UNKNOWN);
276 bool resultBool = OH_ArkWeb_SetSchemeHandler(scheme, webTag, schemeHandler);
277 EXPECT_FALSE(resultBool);
278 resultBool = OH_ArkWebServiceWorker_SetSchemeHandler(scheme, schemeHandler);
279 EXPECT_FALSE(resultBool);
280 OH_ArkWeb_CreateSchemeHandler(&schemeHandler);
281 ArkWeb_Response* response = nullptr;
282 OH_ArkWeb_CreateResponse(&response);
283 }
284
285 /**
286 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_001
287 * @tc.desc : g_SchemeHandlerApi is not nullptr
288 */
289 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_001, TestSize.Level1) {
290 ArkWeb_SchemeHandler* schemeHandler = nullptr;
291 NWebHelper::Instance().nwebEngine_ = nullptr;
292 NWebHelper::Instance().bundlePath_ = BUNDLE_PATH;
293 NWebHelper::Instance().LoadWebEngine(false, false);
294 OH_ArkWeb_CreateSchemeHandler(&schemeHandler);
295
296 ArkWeb_RequestHeaderList* headerList = nullptr;
297 OH_ArkWebRequestHeaderList_Destroy(headerList);
298 std::ignore = OH_ArkWebRequestHeaderList_GetSize(headerList);
299 int32_t index = 0;
300 char* key = nullptr;
301 char* value = nullptr;
302 OH_ArkWebRequestHeaderList_GetHeader(headerList, index, &key, &value);
303 ArkWeb_ResourceRequest* resourceRequest = nullptr;
304 char* method = nullptr;
305 OH_ArkWebResourceRequest_GetMethod(resourceRequest, &method);
306 char* url = nullptr;
307 OH_ArkWebResourceRequest_GetUrl(resourceRequest, &url);
308 ArkWeb_HttpBodyStream* httpBodyStream = nullptr;
309 OH_ArkWebResourceRequest_GetHttpBodyStream(resourceRequest, &httpBodyStream);
310 OH_ArkWebResourceRequest_DestroyHttpBodyStream(httpBodyStream);
311 std::ignore = OH_ArkWebResourceRequest_GetResourceType(resourceRequest);
312 char* frameUrl = nullptr;
313 OH_ArkWebResourceRequest_GetFrameUrl(resourceRequest, &frameUrl);
314 void* userData = nullptr;
315 int32_t result = OH_ArkWebHttpBodyStream_SetUserData(httpBodyStream, userData);
316 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
317 std::ignore = OH_ArkWebHttpBodyStream_GetUserData(httpBodyStream);
318
319 NWebHelper::Instance().nwebEngine_ = nullptr;
320 }
321
322 /**
323 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_002
324 * @tc.desc : g_SchemeHandlerApi is not nullptr
325 */
326 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_002, TestSize.Level1) {
327 NWebHelper::Instance().nwebEngine_ = nullptr;
328 NWebHelper::Instance().bundlePath_ = BUNDLE_PATH;
329 NWebHelper::Instance().LoadWebEngine(false, false);
330 NWebHelper::Instance().bundlePath_ = "";
331 const char* scheme = "scheme";
332 int32_t option = 0;
333 int32_t result = OH_ArkWeb_RegisterCustomSchemes(scheme, option);
334 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
335
336 ArkWeb_HttpBodyStream* httpBodyStream = nullptr;
337 ArkWeb_HttpBodyStreamReadCallback readCallback = nullptr;
338 result = OH_ArkWebHttpBodyStream_SetReadCallback(httpBodyStream, readCallback);
339 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
340 ArkWeb_HttpBodyStreamInitCallback initCallback = nullptr;
341 result = OH_ArkWebHttpBodyStream_Init(httpBodyStream, initCallback);
342 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
343 const ArkWeb_HttpBodyStream* httpBodyStream1 = nullptr;
344 uint8_t buffer[256] = {0};
345 int bufLen = sizeof(buffer);
346 OH_ArkWebHttpBodyStream_Read(httpBodyStream1, buffer, bufLen);
347 std::ignore = OH_ArkWebHttpBodyStream_GetSize(httpBodyStream1);
348 std::ignore = OH_ArkWebHttpBodyStream_GetPosition(httpBodyStream1);
349 std::ignore = OH_ArkWebHttpBodyStream_IsChunked(httpBodyStream);
350 std::ignore = OH_ArkWebHttpBodyStream_IsEof(httpBodyStream);
351 std::ignore = OH_ArkWebHttpBodyStream_IsInMemory(httpBodyStream);
352 const ArkWeb_ResourceRequest* resourceRequest = nullptr;
353 result = OH_ArkWebResourceRequest_Destroy(resourceRequest);
354 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
355 char* referrer = nullptr;
356 OH_ArkWebResourceRequest_GetReferrer(resourceRequest, &referrer);
357
358 NWebHelper::Instance().nwebEngine_ = nullptr;
359 }
360
361 /**
362 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_003
363 * @tc.desc : g_SchemeHandlerApi is not nullptr
364 */
365 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_003, TestSize.Level1) {
366 ArkWeb_SchemeHandler* schemeHandler = nullptr;
367 NWebHelper::Instance().nwebEngine_ = nullptr;
368 NWebHelper::Instance().bundlePath_ = BUNDLE_PATH;
369 NWebHelper::Instance().LoadWebEngine(false, false);
370 const char* scheme = "scheme";
371 const char* webTag = "webTag";
372 std::ignore = OH_ArkWeb_SetSchemeHandler(scheme, webTag, schemeHandler);
373
374 ArkWeb_ResourceRequest* resourceRequest = nullptr;
375 void* userData = nullptr;
376 int32_t result = OH_ArkWebResourceRequest_SetUserData(resourceRequest, userData);
377 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
378 const ArkWeb_ResourceRequest* resourceRequest1 = nullptr;
379 std::ignore = OH_ArkWebResourceRequest_GetUserData(resourceRequest1);
380 ArkWeb_RequestHeaderList* requestHeaderList = nullptr;
381 OH_ArkWebResourceRequest_GetRequestHeaders(resourceRequest1, &requestHeaderList);
382 std::ignore = OH_ArkWebResourceRequest_IsRedirect(resourceRequest1);
383 std::ignore = OH_ArkWebResourceRequest_IsMainFrame(resourceRequest1);
384 std::ignore = OH_ArkWebResourceRequest_HasGesture(resourceRequest);
385 result = OH_ArkWeb_ClearSchemeHandlers(webTag);
386 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
387 result = OH_ArkWebServiceWorker_ClearSchemeHandlers();
388 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
389 OH_ArkWeb_DestroySchemeHandler(schemeHandler);
390 result = OH_ArkWebSchemeHandler_SetUserData(schemeHandler, userData);
391 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
392 const ArkWeb_SchemeHandler* schemeHandler1 = nullptr;
393 std::ignore = OH_ArkWebSchemeHandler_GetUserData(schemeHandler1);
394
395 NWebHelper::Instance().nwebEngine_ = nullptr;
396 }
397
398 /**
399 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_004
400 * @tc.desc : g_SchemeHandlerApi is not nullptr
401 */
402 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_004, TestSize.Level1) {
403 ArkWeb_SchemeHandler* schemeHandler = nullptr;
404 NWebHelper::Instance().nwebEngine_ = nullptr;
405 NWebHelper::Instance().bundlePath_ = BUNDLE_PATH;
406 NWebHelper::Instance().LoadWebEngine(false, false);
407 const char* scheme = "scheme";
408 std::ignore = OH_ArkWebServiceWorker_SetSchemeHandler(scheme, schemeHandler);
409
410 ArkWeb_OnRequestStart onRequestStart = nullptr;
411 int32_t result = OH_ArkWebSchemeHandler_SetOnRequestStart(schemeHandler, onRequestStart);
412 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
413 ArkWeb_OnRequestStop onRequestStop = nullptr;
414 result = OH_ArkWebSchemeHandler_SetOnRequestStop(schemeHandler, onRequestStop);
415 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
416 ArkWeb_Response* response = nullptr;
417 OH_ArkWeb_DestroyResponse(response);
418 const char* url = "www.example.com";
419 result = OH_ArkWebResponse_SetUrl(response, url);
420 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
421 char* url1 = nullptr;
422 OH_ArkWebResponse_GetUrl(response, &url1);
423
424 ArkWeb_NetError errorCode = ARKWEB_NET_OK;
425 result = OH_ArkWebResponse_SetError(response, errorCode);
426 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
427 std::ignore = OH_ArkWebResponse_GetError(response);
428 int status = -1;
429 result = OH_ArkWebResponse_SetStatus(response, status);
430 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
431 std::ignore = OH_ArkWebResponse_GetStatus(response);
432
433 const char* statusText = "Test Status Text";
434 result = OH_ArkWebResponse_SetStatusText(response, statusText);
435 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
436 char* statusTextGet = nullptr;
437 OH_ArkWebResponse_GetStatusText(response, &statusTextGet);
438
439 const char* mimeType = "text/plain";
440 result = OH_ArkWebResponse_SetMimeType(response, mimeType);
441 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
442 char* mimeTypeRes = nullptr;
443 OH_ArkWebResponse_GetMimeType(response, &mimeTypeRes);
444 const char* charSet = "";
445 result = OH_ArkWebResponse_SetCharset(response, charSet);
446 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
447 char* charSetRes = nullptr;
448 OH_ArkWebResponse_GetCharset(response, &charSetRes);
449 const char* name = "TestHeaderName";
450 const char* value = "TestHeaderValue";
451 result = OH_ArkWebResponse_SetHeaderByName(response, name, value, true);
452 EXPECT_NE(result, ARKWEB_ERROR_UNKNOWN);
453 char* valueRes = nullptr;
454 OH_ArkWebResponse_GetHeaderByName(response, name, &valueRes);
455
456 NWebHelper::Instance().nwebEngine_ = nullptr;
457 }
458
459 /**
460 * @tc.name : OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_005
461 * @tc.desc : g_SchemeHandlerApi is not nullptr
462 */
463 HWTEST_F(OHArkwebSchemeHandlerTest, OHArkwebSchemeHandlerTest_SchemeHandlerApiIsNotNull_005, TestSize.Level1) {
464 NWebHelper::Instance().nwebEngine_ = nullptr;
465 NWebHelper::Instance().bundlePath_ = BUNDLE_PATH;
466 NWebHelper::Instance().LoadWebEngine(false, false);
467 ArkWeb_Response* response = nullptr;
468 OH_ArkWeb_CreateResponse(&response);
469
470 ArkWeb_ResourceHandler* resourceHandler = nullptr;
471 int32_t res = OH_ArkWebResourceHandler_Destroy(resourceHandler);
472 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
473 res = OH_ArkWebResourceHandler_DidReceiveResponse(resourceHandler, response);
474 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
475 const uint8_t* buffer = reinterpret_cast<const uint8_t*>("TestBuffer");
476 int64_t bufLen = strlen("TestBuffer");
477 res = OH_ArkWebResourceHandler_DidReceiveData(nullptr, buffer, bufLen);
478 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
479 res = OH_ArkWebResourceHandler_DidFinish(nullptr);
480 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
481 ArkWeb_NetError errorCode = ARKWEB_NET_OK;
482 res = OH_ArkWebResourceHandler_DidFailWithError(resourceHandler, errorCode);
483 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
484 char* str = nullptr;
485 OH_ArkWeb_ReleaseString(str);
486 uint8_t* byteArray = nullptr;
487 OH_ArkWeb_ReleaseByteArray(byteArray);
488 ArkWeb_SchemeHandler* schemeHandler = nullptr;
489 res = OH_ArkWebSchemeHandler_SetFromEts(schemeHandler, true);
490 EXPECT_NE(res, ARKWEB_ERROR_UNKNOWN);
491
492 NWebHelper::Instance().nwebEngine_ = nullptr;
493 }
494
495 }
496 }
497
498