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 #include "parameter.h"
21 #include "parameters.h"
22
23 #define private public
24 #include "arkweb_utils.h"
25 #include "base/web/webview/interfaces/native/native_javascript_execute_callback.h"
26 #include "native_interface_arkweb.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace {
32 ArkWeb_ErrorCode g_errorCode = ArkWeb_ErrorCode::ARKWEB_SUCCESS;
OH_ArkWeb_OnCookieSaveCallbackImpl(ArkWeb_ErrorCode errorCode)33 void OH_ArkWeb_OnCookieSaveCallbackImpl(ArkWeb_ErrorCode errorCode) {
34 g_errorCode = errorCode;
35 }
36 }
37
38 namespace OHOS {
39 namespace NWeb {
40
41 class NativeInterfaceArkWebTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void NativeInterfaceArkWebTest::SetUpTestCase(void) {}
50
TearDownTestCase(void)51 void NativeInterfaceArkWebTest::TearDownTestCase(void) {}
52
SetUp(void)53 void NativeInterfaceArkWebTest::SetUp(void) {}
54
TearDown(void)55 void NativeInterfaceArkWebTest::TearDown(void) {}
56
57 /**
58 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_OH_NativeArkWeb_RunJavaScript_01
59 * @tc.desc : Test OH_NativeArkWeb_RunJavaScript
60 */
61 HWTEST_F(NativeInterfaceArkWebTest,
62 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_OH_NativeArkWeb_RunJavaScript_01, TestSize.Level1) {
63 const char* webTag = "";
64 const char* jsCode = "";
65 NativeArkWeb_OnJavaScriptCallback callback = nullptr;
66 OH_NativeArkWeb_RunJavaScript(webTag, jsCode, callback);
67 }
68
69 /**
70 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_OH_NativeArkWeb_RegisterJavaScriptProxy_01
71 * @tc.desc : Test OH_NativeArkWeb_RegisterJavaScriptProxy
72 */
73 HWTEST_F(NativeInterfaceArkWebTest,
74 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_OH_NativeArkWeb_RegisterJavaScriptProxy_01, TestSize.Level1) {
75 const char* webTag = "";
76 const char* objName = "";
77 const char* methodName[3] = { "method1", "method2", "method3" };
78 NativeArkWeb_OnJavaScriptProxyCallback callback[3] = { nullptr, nullptr, nullptr };
79 int32_t size = 3;
80 OH_NativeArkWeb_RegisterJavaScriptProxy(webTag, objName, methodName, callback, size, false);
81 }
82
83 /**
84 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_UnregisterJavaScriptProxy_01
85 * @tc.desc : Test OH_NativeArkWeb_UnregisterJavaScriptProxy
86 */
87 HWTEST_F(NativeInterfaceArkWebTest,
88 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_UnregisterJavaScriptProxy_01, TestSize.Level1) {
89 const char* webTag = "";
90 const char* objName = "";
91 OH_NativeArkWeb_UnregisterJavaScriptProxy(webTag, objName);
92 }
93
94 /**
95 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_SetDestroyCallback_01
96 * @tc.desc : Test OH_NativeArkWeb_SetDestroyCallback
97 */
98 HWTEST_F(NativeInterfaceArkWebTest,
99 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_SetDestroyCallback_01, TestSize.Level1) {
100 const char* webTag = "";
101 NativeArkWeb_OnDestroyCallback callback = nullptr;
102 OH_NativeArkWeb_SetDestroyCallback(webTag, callback);
103 }
104
105 /**
106 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_GetDestroyCallback_01
107 * @tc.desc : Test OH_NativeArkWeb_GetDestroyCallback
108 */
109 HWTEST_F(NativeInterfaceArkWebTest,
110 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_GetDestroyCallback_01, TestSize.Level1) {
111 const char* webTag = "";
112 NativeArkWeb_OnDestroyCallback callback = OH_NativeArkWeb_GetDestroyCallback(webTag);
113 EXPECT_TRUE(callback == nullptr);
114 }
115
116 /**
117 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_SetJavaScriptProxyValidCallback_01
118 * @tc.desc : Test OH_NativeArkWeb_SetJavaScriptProxyValidCallback
119 */
120 HWTEST_F(NativeInterfaceArkWebTest,
121 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_SetJavaScriptProxyValidCallback_01, TestSize.Level1) {
122 const char* webTag = "";
123 NativeArkWeb_OnValidCallback callback = nullptr;
124 OH_NativeArkWeb_SetJavaScriptProxyValidCallback(webTag, callback);
125 }
126
127 /**
128 * @tc.name : OHNativeInterfaceArkWebTest_OH_NativeArkWeb_GetJavaScriptProxyValidCallback_01
129 * @tc.desc : Test OH_NativeArkWeb_GetJavaScriptProxyValidCallback
130 */
131 HWTEST_F(NativeInterfaceArkWebTest,
132 OHNativeInterfaceArkWebTest_OH_NativeArkWeb_GetJavaScriptProxyValidCallback_01, TestSize.Level1) {
133 const char* webTag = "";
134 NativeArkWeb_OnValidCallback callback =
135 OH_NativeArkWeb_GetJavaScriptProxyValidCallback(webTag);
136 EXPECT_TRUE(callback == nullptr);
137 }
138
139 /**
140 * @tc.name : OH_NativeArkWeb_GetBlanklessInfoWithKey_01
141 * @tc.desc : Test OH_NativeArkWeb_GetBlanklessInfoWithKey
142 */
143 HWTEST_F(NativeInterfaceArkWebTest, OH_NativeArkWeb_GetBlanklessInfoWithKey_01, TestSize.Level1) {
144 bool enabled = OHOS::system::GetBoolParameter("web.blankless.enabled", false);
145
146 OHOS::system::SetParameter("web.blankless.enabled", "true");
147 auto info1 = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "");
148 EXPECT_EQ(info1.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_INVALID_ARGS);
149 auto info2 = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "OH_NativeArkWeb_GetBlanklessInfoWithKey");
150 EXPECT_EQ(info2.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_UNKNOWN);
151
152 OHOS::system::SetParameter("web.blankless.enabled", "false");
153 auto info3 = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "");
154 EXPECT_EQ(info3.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
155 auto info4 = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "OH_NativeArkWeb_GetBlanklessInfoWithKey");
156 EXPECT_EQ(info4.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
157
158 OHOS::system::SetParameter("web.blankless.enabled", enabled ? "true" : "false");
159 }
160
161 /**
162 * @tc.name : OH_NativeArkWeb_SetBlanklessLoadingWithKey_01
163 * @tc.desc : Test OH_NativeArkWeb_SetBlanklessLoadingWithKey
164 */
165 HWTEST_F(NativeInterfaceArkWebTest, OH_NativeArkWeb_SetBlanklessLoadingWithKey_01, TestSize.Level1) {
166 bool enabled = OHOS::system::GetBoolParameter("web.blankless.enabled", false);
167
168 OHOS::system::SetParameter("web.blankless.enabled", "true");
169 auto errCode1 = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "", true);
170 EXPECT_EQ(errCode1, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_INVALID_ARGS);
171 auto errCode2 = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "OH_NativeArkWeb_SetBlanklessLoadingWithKey", false);
172 EXPECT_EQ(errCode2, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_UNKNOWN);
173
174 OHOS::system::SetParameter("web.blankless.enabled", "false");
175 auto errCode3 = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "", true);
176 EXPECT_EQ(errCode3, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
177 auto errCode4 = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "OH_NativeArkWeb_SetBlanklessLoadingWithKey", false);
178 EXPECT_EQ(errCode4, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
179
180 OHOS::system::SetParameter("web.blankless.enabled", enabled ? "true" : "false");
181 }
182
183 /**
184 * @tc.name : OH_NativeArkWeb_ClearBlanklessLoadingCache_01
185 * @tc.desc : Test OH_NativeArkWeb_ClearBlanklessLoadingCache
186 */
187 HWTEST_F(NativeInterfaceArkWebTest, OH_NativeArkWeb_ClearBlanklessLoadingCache_01, TestSize.Level1) {
188 bool enabled = OHOS::system::GetBoolParameter("web.blankless.enabled", false);
189
190 OHOS::system::SetParameter("web.blankless.enabled", "false");
191 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, 0);
192
193 OHOS::system::SetParameter("web.blankless.enabled", "true");
194 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, 0);
195
196 const char* keys1[] = {};
197 EXPECT_EQ(sizeof(keys1) / sizeof(const char*), 0);
198 OH_NativeArkWeb_ClearBlanklessLoadingCache(keys1, 0);
199
200 std::string longStr;
201 // Test for key length over MAX_KEY_LENGTH, which is 2048.
202 for (uint32_t idx = 0; idx < 3000; idx++) {
203 longStr += "0";
204 }
205 const char* keys2[3];
206 keys2[0] = "ClearBlanklessLoadingCache";
207 keys2[1] = "";
208 keys2[2] = longStr.c_str();
209 EXPECT_EQ(sizeof(keys2) / sizeof(const char*), 3);
210 OH_NativeArkWeb_ClearBlanklessLoadingCache(keys2, 3);
211
212 const char* keys3[101];
213 // Test for key length over MAX_KEY_COUNT, which is 100.
214 for (uint32_t idx = 0; idx < 101; idx++) {
215 keys3[idx] = "test";
216 }
217 EXPECT_EQ(sizeof(keys3) / sizeof(const char*), 101);
218 OH_NativeArkWeb_ClearBlanklessLoadingCache(keys3, 101);
219
220 const char* keys4[] = { nullptr };
221 EXPECT_EQ(sizeof(keys4) / sizeof(const char*), 1);
222 OH_NativeArkWeb_ClearBlanklessLoadingCache(keys4, 1);
223
224 OHOS::system::SetParameter("web.blankless.enabled", enabled ? "true" : "false");
225 }
226
227 /**
228 * @tc.name : OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity_01
229 * @tc.desc : Test OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity
230 */
231 HWTEST_F(NativeInterfaceArkWebTest, OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity_01, TestSize.Level1) {
232 bool enabled = OHOS::system::GetBoolParameter("web.blankless.enabled", false);
233
234 OHOS::system::SetParameter("web.blankless.enabled", "true");
235 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(0), 0);
236 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(20), 20);
237 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(100), 100);
238 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(1000), 100);
239
240 OHOS::system::SetParameter("web.blankless.enabled", "false");
241 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(0), 0);
242 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(20), 0);
243 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(100), 0);
244 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(1000), 0);
245
246 OHOS::system::SetParameter("web.blankless.enabled", enabled ? "true" : "false");
247 }
248
249 /**
250 * @tc.name : OH_NativeArkWeb_Blankless_Dual_Core_01
251 * @tc.desc : Test OH_NativeArkWeb_Blankless_Dual_Core
252 */
253 HWTEST_F(NativeInterfaceArkWebTest, OH_NativeArkWeb_Blankless_Dual_Core_01, TestSize.Level1) {
254 bool defaultStatus = OHOS::system::GetBoolParameter("web.blankless.enabled", false);
255 OHOS::system::SetParameter("web.blankless.enabled", "true");
256 auto version = ArkWeb::getActiveWebEngineVersion();
257 ArkWeb::setActiveWebEngineVersion(ArkWeb::ArkWebEngineVersion::M114);
258 auto info = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "");
259 EXPECT_EQ(info.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
260 auto errCode = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "", true);
261 EXPECT_EQ(errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_DEVICE_NOT_SUPPORT);
262 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, 0);
263 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(20), 0);
264
265 ArkWeb::setActiveWebEngineVersion(ArkWeb::ArkWebEngineVersion::M132);
266 info = OH_NativeArkWeb_GetBlanklessInfoWithKey("", "");
267 EXPECT_EQ(info.errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_INVALID_ARGS);
268 errCode = OH_NativeArkWeb_SetBlanklessLoadingWithKey("", "", true);
269 EXPECT_EQ(errCode, ArkWeb_BlanklessErrorCode::ARKWEB_BLANKLESS_ERR_INVALID_ARGS);
270 OH_NativeArkWeb_ClearBlanklessLoadingCache(nullptr, 0);
271 EXPECT_EQ(OH_NativeArkWeb_SetBlanklessLoadingCacheCapacity(20), 20);
272
273 ArkWeb::setActiveWebEngineVersion(version);
274 OHOS::system::SetParameter("web.blankless.enabled", defaultStatus ? "true" : "false");
275 }
276
277 /**
278 * @tc.name : OH_ArkWebCookieManager_SaveCookieSync_01
279 * @tc.desc : Test OH_ArkWebCookieManager_SaveCookieSync
280 */
281 HWTEST_F(NativeInterfaceArkWebTest, OH_ArkWebCookieManager_SaveCookieSync_01, TestSize.Level1) {
282 ArkWeb_ErrorCode ret = OH_ArkWebCookieManager_SaveCookieSync();
283 EXPECT_EQ(ret, ArkWeb_ErrorCode::ARKWEB_COOKIE_MANAGER_INITIALIZE_FAILED);
284 }
285
286 /**
287 * @tc.name : OH_ArkWebCookieManager_SaveCookieAsync_01
288 * @tc.desc : Test OH_ArkWebCookieManager_SaveCookieAsync
289 */
290 HWTEST_F(NativeInterfaceArkWebTest, OH_ArkWebCookieManager_SaveCookieAsync_01, TestSize.Level1) {
291 OH_ArkWeb_OnCookieSaveCallback callback = nullptr;
292 g_errorCode = ArkWeb_ErrorCode::ARKWEB_SUCCESS;
293 OH_ArkWebCookieManager_SaveCookieAsync(callback);
294 EXPECT_EQ(g_errorCode, ArkWeb_ErrorCode::ARKWEB_SUCCESS);
295
296 g_errorCode = ArkWeb_ErrorCode::ARKWEB_SUCCESS;
297 callback = OH_ArkWeb_OnCookieSaveCallbackImpl;
298 OH_ArkWebCookieManager_SaveCookieAsync(callback);
299 EXPECT_EQ(g_errorCode, ArkWeb_ErrorCode::ARKWEB_COOKIE_MANAGER_INITIALIZE_FAILED);
300 }
301
302 } // namespace NWeb
303 } // namesapce OHOS