1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17 #include "input_method_controller.h"
18
19 #include "input_data_channel_stub.h"
20 #include "input_method_ability.h"
21 #include "input_method_system_ability.h"
22 #include "task_manager.h"
23 #undef private
24
25 #include <event_handler.h>
26 #include <gtest/gtest.h>
27 #include <string_ex.h>
28
29 #include <condition_variable>
30 #include <csignal>
31 #include <cstdint>
32 #include <mutex>
33 #include <string>
34 #include <vector>
35
36 #include "global.h"
37 #include "i_input_method_agent.h"
38 #include "i_input_method_system_ability.h"
39 #include "identity_checker_mock.h"
40 #include "inputmethod_controller_capi.h"
41 #include "inputmethod_message_handler_proxy_capi.h"
42 #include "input_client_stub.h"
43 #include "input_death_recipient.h"
44 #include "input_method_ability.h"
45 #include "input_method_engine_listener_impl.h"
46 #include "input_method_system_ability_proxy.h"
47 #include "input_method_utils.h"
48 #include "keyboard_listener.h"
49 #include "message_parcel.h"
50 #include "string_ex.h"
51 #include "tdd_util.h"
52 #include "text_listener.h"
53 #include "msg_handler_callback_interface.h"
54
55 using namespace testing;
56 using namespace testing::ext;
57 namespace OHOS {
58 namespace MiscServices {
59 ArrayBuffer g_arrayBufferCapi;
60 std::mutex g_messageHandlerMutex;
61 std::condition_variable g_messageHandlerCv;
62 bool g_onTerminated = false;
63 bool g_onMessage = false;
64 bool g_onTerminatedNew = false;
OnMessageFunc(InputMethod_MessageHandlerProxy * proxy,const char16_t msgId[],size_t msgIdLength,const uint8_t * msgParam,size_t msgParamLength)65 int32_t OnMessageFunc(InputMethod_MessageHandlerProxy *proxy,
66 const char16_t msgId[], size_t msgIdLength, const uint8_t *msgParam, size_t msgParamLength)
67 {
68 std::unique_lock<std::mutex> lock(g_messageHandlerMutex);
69 std::u16string msgIdStr(msgId, msgIdLength);
70 g_arrayBufferCapi.msgId = Str16ToStr8(msgIdStr);
71 g_arrayBufferCapi.msgParam.assign(msgParam, msgParam + msgParamLength);
72 g_onMessage = true;
73 g_messageHandlerCv.notify_one();
74 return 0;
75 }
76
WaitOnMessageFunc(const ArrayBuffer & arrayBuffer)77 bool WaitOnMessageFunc(const ArrayBuffer &arrayBuffer)
78 {
79 std::unique_lock<std::mutex> lock(g_messageHandlerMutex);
80 g_messageHandlerCv.wait_for(lock, std::chrono::seconds(1), [&arrayBuffer]() {
81 return g_arrayBufferCapi == arrayBuffer;
82 });
83 return g_arrayBufferCapi == arrayBuffer;
84 }
OnTerminatedFunc(InputMethod_MessageHandlerProxy * proxy)85 int32_t OnTerminatedFunc(InputMethod_MessageHandlerProxy *proxy)
86 {
87 g_onTerminated = true;
88 return 0;
89 }
90
OnTerminatedFuncNew(InputMethod_MessageHandlerProxy * proxy)91 int32_t OnTerminatedFuncNew(InputMethod_MessageHandlerProxy *proxy)
92 {
93 g_onTerminatedNew = true;
94 return 0;
95 }
GetTextConfigFunc(InputMethod_TextEditorProxy * proxy,InputMethod_TextConfig * config)96 void GetTextConfigFunc(InputMethod_TextEditorProxy *proxy, InputMethod_TextConfig *config) { }
InsertTextFunc(InputMethod_TextEditorProxy * proxy,const char16_t * text,size_t length)97 void InsertTextFunc(InputMethod_TextEditorProxy *proxy, const char16_t *text, size_t length) { }
DeleteForwardFunc(InputMethod_TextEditorProxy * proxy,int32_t length)98 void DeleteForwardFunc(InputMethod_TextEditorProxy *proxy, int32_t length) { }
DeleteBackwardFunc(InputMethod_TextEditorProxy * proxy,int32_t length)99 void DeleteBackwardFunc(InputMethod_TextEditorProxy *proxy, int32_t length) { }
SendKeyboardStatusFunc(InputMethod_TextEditorProxy * proxy,InputMethod_KeyboardStatus status)100 void SendKeyboardStatusFunc(InputMethod_TextEditorProxy *proxy, InputMethod_KeyboardStatus status) { }
SendEnterKeyFunc(InputMethod_TextEditorProxy * proxy,InputMethod_EnterKeyType type)101 void SendEnterKeyFunc(InputMethod_TextEditorProxy *proxy, InputMethod_EnterKeyType type) { }
MoveCursorFunc(InputMethod_TextEditorProxy * proxy,InputMethod_Direction direction)102 void MoveCursorFunc(InputMethod_TextEditorProxy *proxy, InputMethod_Direction direction) { }
HandleSetSelectionFunc(InputMethod_TextEditorProxy * proxy,int32_t start,int32_t end)103 void HandleSetSelectionFunc(InputMethod_TextEditorProxy *proxy, int32_t start, int32_t end) { }
HandleExtendActionFunc(InputMethod_TextEditorProxy * proxy,InputMethod_ExtendAction action)104 void HandleExtendActionFunc(InputMethod_TextEditorProxy *proxy, InputMethod_ExtendAction action) { }
GetleftTextOfCursorFunc(InputMethod_TextEditorProxy * proxy,int32_t number,char16_t text[],size_t * length)105 void GetleftTextOfCursorFunc(InputMethod_TextEditorProxy *proxy, int32_t number, char16_t text[], size_t *length) { }
GetRightTextOfCursorFunc(InputMethod_TextEditorProxy * proxy,int32_t number,char16_t text[],size_t * length)106 void GetRightTextOfCursorFunc(InputMethod_TextEditorProxy *proxy, int32_t number, char16_t text[], size_t *length) { }
GetTextIndexAtCursorFunc(InputMethod_TextEditorProxy * proxy)107 int32_t GetTextIndexAtCursorFunc(InputMethod_TextEditorProxy *proxy)
108 {
109 return 0;
110 }
ReceivePrivateCommandFunc(InputMethod_TextEditorProxy * proxy,InputMethod_PrivateCommand * privateCommand[],size_t size)111 int32_t ReceivePrivateCommandFunc(
112 InputMethod_TextEditorProxy *proxy, InputMethod_PrivateCommand *privateCommand[], size_t size)
113 {
114 return 0;
115 }
SetPreviewTextFunc(InputMethod_TextEditorProxy * proxy,const char16_t * text,size_t length,int32_t start,int32_t end)116 int32_t SetPreviewTextFunc(
117 InputMethod_TextEditorProxy *proxy, const char16_t *text, size_t length, int32_t start, int32_t end)
118 {
119 return 0;
120 }
FinishTextPreviewFunc(InputMethod_TextEditorProxy * proxy)121 void FinishTextPreviewFunc(InputMethod_TextEditorProxy *proxy) { }
122 class MessageHandlerCallback : public MsgHandlerCallbackInterface {
123 public:
124 using onTerminatedFunc = std::function<void()>;
125 using onMessageFunc = std::function<void(const ArrayBuffer &arrayBuffer)>;
MessageHandlerCallback()126 MessageHandlerCallback() {};
~MessageHandlerCallback()127 virtual ~MessageHandlerCallback() {};
128 int32_t OnTerminated() override;
129 int32_t OnMessage(const ArrayBuffer &arrayBuffer) override;
130 void SetOnTernimateFunc(onTerminatedFunc func);
131 void SetOnMessageFunc(onMessageFunc func);
132 bool CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute, bool isOnMessageExcute);
133 static void OnMessageCallback(const ArrayBuffer &arrayBuffer);
134 static bool WaitSendMessage(const ArrayBuffer &arrayBuffer);
135 static void ClearArrayBuffer();
136 static ArrayBuffer GetTimingArrayBuffer();
137 void ClearParam();
138 private:
139 onTerminatedFunc onTerminatedFunc_ = nullptr;
140 onMessageFunc onMessageFunc_ = nullptr;
141 bool isTriggerOnTerminated_ = false;
142 bool isTriggerOnMessage_ = false;
143 static std::mutex messageHandlerMutex_;
144 static std::condition_variable messageHandlerCv_;
145 static ArrayBuffer arrayBuffer_;
146 static ArrayBuffer timingArrayBuffer_;
147 };
148 std::mutex MessageHandlerCallback::messageHandlerMutex_;
149 std::condition_variable MessageHandlerCallback::messageHandlerCv_;
150 ArrayBuffer MessageHandlerCallback::arrayBuffer_;
151 ArrayBuffer MessageHandlerCallback::timingArrayBuffer_;
152
OnTerminated()153 int32_t MessageHandlerCallback::OnTerminated()
154 {
155 isTriggerOnTerminated_ = true;
156 if (onTerminatedFunc_ != nullptr) {
157 onTerminatedFunc_();
158 }
159 return ErrorCode::NO_ERROR;
160 }
161
OnMessage(const ArrayBuffer & arrayBuffer)162 int32_t MessageHandlerCallback::OnMessage(const ArrayBuffer &arrayBuffer)
163 {
164 std::string msgParam(arrayBuffer_.msgParam.begin(), arrayBuffer_.msgParam.end());
165 std::string msgParam1(arrayBuffer.msgParam.begin(), arrayBuffer.msgParam.end());
166 IMSA_HILOGE("arrayBuffer_ msgId: %{public}s, msgParam: %{publid}s",
167 arrayBuffer_.msgId.c_str(), msgParam.c_str());
168 IMSA_HILOGE("arrayBuffer msgId: %{public}s, msgParam: %{publid}s",
169 arrayBuffer.msgId.c_str(), msgParam1.c_str());
170 isTriggerOnMessage_ = true;
171 if (onMessageFunc_ != nullptr) {
172 onMessageFunc_(arrayBuffer);
173 }
174 OnMessageCallback(arrayBuffer);
175 timingArrayBuffer_.msgId += arrayBuffer.msgId;
176 timingArrayBuffer_.msgParam.insert(
177 timingArrayBuffer_.msgParam.end(), arrayBuffer.msgParam.begin(), arrayBuffer.msgParam.end());
178 return ErrorCode::NO_ERROR;
179 }
180
SetOnTernimateFunc(onTerminatedFunc func)181 void MessageHandlerCallback::SetOnTernimateFunc(onTerminatedFunc func)
182 {
183 onTerminatedFunc_ = func;
184 }
185
SetOnMessageFunc(onMessageFunc func)186 void MessageHandlerCallback::SetOnMessageFunc(onMessageFunc func)
187 {
188 onMessageFunc_ = func;
189 }
190
CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute,bool isOnMessageExcute)191 bool MessageHandlerCallback::CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute, bool isOnMessageExcute)
192 {
193 return isOnTerminatedExcute == isTriggerOnTerminated_ && isOnMessageExcute == isTriggerOnMessage_;
194 }
195
OnMessageCallback(const ArrayBuffer & arrayBuffer)196 void MessageHandlerCallback::OnMessageCallback(const ArrayBuffer &arrayBuffer)
197 {
198 IMSA_HILOGI("OnMessageCallback");
199 std::unique_lock<std::mutex> lock(messageHandlerMutex_);
200 arrayBuffer_ = arrayBuffer;
201 messageHandlerCv_.notify_one();
202 }
203
WaitSendMessage(const ArrayBuffer & arrayBuffer)204 bool MessageHandlerCallback::WaitSendMessage(const ArrayBuffer &arrayBuffer)
205 {
206 std::unique_lock<std::mutex> lock(messageHandlerMutex_);
207 messageHandlerCv_.wait_for(lock, std::chrono::seconds(1), [&arrayBuffer]() {
208 return arrayBuffer_ == arrayBuffer;
209 });
210 return arrayBuffer_ == arrayBuffer;
211 }
212
ClearArrayBuffer()213 void MessageHandlerCallback::ClearArrayBuffer()
214 {
215 arrayBuffer_.msgId.clear();
216 arrayBuffer_.msgParam.clear();
217 g_arrayBufferCapi.msgId.clear();
218 g_arrayBufferCapi.msgParam.clear();
219 timingArrayBuffer_.msgId.clear();
220 timingArrayBuffer_.msgParam.clear();
221 }
222
GetTimingArrayBuffer()223 ArrayBuffer MessageHandlerCallback::GetTimingArrayBuffer()
224 {
225 return timingArrayBuffer_;
226 }
227
ClearParam()228 void MessageHandlerCallback::ClearParam()
229 {
230 isTriggerOnTerminated_ = false;
231 isTriggerOnMessage_ = false;
232 }
233
234 class InputMethodMessageHandlerTest : public testing::Test {
235 public:
236 static void SetUpTestCase(void);
237 static void TearDownTestCase(void);
238 void SetUp();
239 void TearDown();
240 static void SetSecurityModeEnable(int32_t securityMode);
241 static void ResetParam();
242 static void ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy *messageHandlerProxy);
243 static void TestGetMessageHandlerProxyMember(InputMethod_MessageHandlerProxy *messageHandlerProxy);
244 static void ConstructTextEditorProxy(InputMethod_TextEditorProxy *textEditorProxy);
245 static sptr<InputMethodController> inputMethodController_;
246 static sptr<InputMethodAbility> inputMethodAbility_;
247 static sptr<InputMethodSystemAbility> imsa_;
248 static sptr<InputMethodSystemAbilityProxy> imsaProxy_;
249 static std::shared_ptr<InputMethodEngineListenerImpl> imeListener_;
250 static std::shared_ptr<AppExecFwk::EventHandler> textConfigHandler_;
251 static sptr<OnTextChangedListener> textListener_;
252 static InputMethod_AttachOptions *option_;
253 static InputMethod_TextEditorProxy *textEditorProxy_;
254 static InputMethod_MessageHandlerProxy *messageHanlderProxy_;
255 };
256 sptr<InputMethodController> InputMethodMessageHandlerTest::inputMethodController_;
257 sptr<InputMethodAbility> InputMethodMessageHandlerTest::inputMethodAbility_;
258 sptr<InputMethodSystemAbility> InputMethodMessageHandlerTest::imsa_;
259 sptr<InputMethodSystemAbilityProxy> InputMethodMessageHandlerTest::imsaProxy_;
260 std::shared_ptr<InputMethodEngineListenerImpl> InputMethodMessageHandlerTest::imeListener_;
261 sptr<OnTextChangedListener> InputMethodMessageHandlerTest::textListener_;
262 std::shared_ptr<AppExecFwk::EventHandler> InputMethodMessageHandlerTest::textConfigHandler_ { nullptr };
263 InputMethod_AttachOptions *InputMethodMessageHandlerTest::option_ = nullptr;
264 InputMethod_TextEditorProxy *InputMethodMessageHandlerTest::textEditorProxy_ = nullptr;
265 InputMethod_MessageHandlerProxy *InputMethodMessageHandlerTest::messageHanlderProxy_ = nullptr;
266
SetUpTestCase(void)267 void InputMethodMessageHandlerTest::SetUpTestCase(void)
268 {
269 IMSA_HILOGI("InputMethodMessageHandlerTest::SetUpTestCase");
270 IdentityCheckerMock::ResetParam();
271 imsa_ = new (std::nothrow) InputMethodSystemAbility();
272 if (imsa_ == nullptr) {
273 return;
274 }
275 imsa_->OnStart();
276 imsa_->userId_ = TddUtil::GetCurrentUserId();
277 imsa_->identityChecker_ = std::make_shared<IdentityCheckerMock>();
278 sptr<InputMethodSystemAbilityStub> serviceStub = imsa_;
279 imsaProxy_ = new (std::nothrow) InputMethodSystemAbilityProxy(serviceStub->AsObject());
280 if (imsaProxy_ == nullptr) {
281 return;
282 }
283 IdentityCheckerMock::SetFocused(true);
284
285 inputMethodAbility_ = InputMethodAbility::GetInstance();
286 inputMethodAbility_->abilityManager_ = imsaProxy_;
287 textListener_ = new TextListener();
288 TddUtil::InitCurrentImePermissionInfo();
289 IdentityCheckerMock::SetBundleName(TddUtil::currentBundleNameMock_);
290 inputMethodAbility_->SetCoreAndAgent();
291 imeListener_ = std::make_shared<InputMethodEngineListenerImpl>(textConfigHandler_);
292 inputMethodAbility_->SetImeListener(imeListener_);
293
294 inputMethodController_ = InputMethodController::GetInstance();
295 inputMethodController_->abilityManager_ = imsaProxy_;
296
297 option_ = OH_AttachOptions_Create(true);
298 textEditorProxy_ = OH_TextEditorProxy_Create();
299 ConstructTextEditorProxy(textEditorProxy_);
300 messageHanlderProxy_ = OH_MessageHandlerProxy_Create();
301 ConstructMessageHandlerProxy(messageHanlderProxy_);
302 }
303
TearDownTestCase(void)304 void InputMethodMessageHandlerTest::TearDownTestCase(void)
305 {
306 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDownTestCase");
307 inputMethodController_->SetControllerListener(nullptr);
308 IdentityCheckerMock::ResetParam();
309 imsa_->OnStop();
310 OH_AttachOptions_Destroy(option_);
311 OH_TextEditorProxy_Destroy(textEditorProxy_);
312 OH_MessageHandlerProxy_Destroy(messageHanlderProxy_);
313 }
314
SetUp(void)315 void InputMethodMessageHandlerTest::SetUp(void)
316 {
317 IMSA_HILOGI("InputMethodMessageHandlerTest::SetUp");
318 TaskManager::GetInstance().SetInited(true);
319 }
320
TearDown(void)321 void InputMethodMessageHandlerTest::TearDown(void)
322 {
323 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDown");
324 std::this_thread::sleep_for(std::chrono::seconds(1));
325 TaskManager::GetInstance().Reset();
326 ResetParam();
327 }
328
SetSecurityModeEnable(int32_t securityMode)329 void InputMethodMessageHandlerTest::SetSecurityModeEnable(int32_t securityMode)
330 {
331 if (inputMethodAbility_ != nullptr) {
332 inputMethodAbility_->securityMode_.store(securityMode);
333 }
334 }
335
ResetParam()336 void InputMethodMessageHandlerTest::ResetParam()
337 {
338 inputMethodController_->Close();
339 if (inputMethodAbility_ != nullptr) {
340 inputMethodAbility_->securityMode_.store(-1);
341 }
342 InputMethodEngineListenerImpl::ResetParam();
343 MessageHandlerCallback::ClearArrayBuffer();
344 inputMethodAbility_->RegisterMsgHandler();
345 inputMethodController_->RegisterMsgHandler();
346 g_onTerminated = false;
347 g_onMessage = false;
348 g_onTerminatedNew = false;
349 }
350
ConstructTextEditorProxy(InputMethod_TextEditorProxy * textEditorProxy)351 void InputMethodMessageHandlerTest::ConstructTextEditorProxy(InputMethod_TextEditorProxy *textEditorProxy)
352 {
353 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetTextConfigFunc(textEditorProxy, GetTextConfigFunc));
354 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetInsertTextFunc(textEditorProxy, InsertTextFunc));
355 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetDeleteForwardFunc(textEditorProxy, DeleteForwardFunc));
356 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetDeleteBackwardFunc(textEditorProxy, DeleteBackwardFunc));
357 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSendKeyboardStatusFunc(textEditorProxy, SendKeyboardStatusFunc));
358 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSendEnterKeyFunc(textEditorProxy, SendEnterKeyFunc));
359 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetMoveCursorFunc(textEditorProxy, MoveCursorFunc));
360 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetHandleSetSelectionFunc(textEditorProxy, HandleSetSelectionFunc));
361 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetHandleExtendActionFunc(textEditorProxy, HandleExtendActionFunc));
362 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetLeftTextOfCursorFunc(textEditorProxy, GetleftTextOfCursorFunc));
363 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetRightTextOfCursorFunc(textEditorProxy, GetRightTextOfCursorFunc));
364 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetTextIndexAtCursorFunc(textEditorProxy, GetTextIndexAtCursorFunc));
365 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetReceivePrivateCommandFunc(textEditorProxy, ReceivePrivateCommandFunc));
366 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSetPreviewTextFunc(textEditorProxy, SetPreviewTextFunc));
367 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetFinishTextPreviewFunc(textEditorProxy, FinishTextPreviewFunc));
368 }
369
ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy * messageHandlerProxy)370 void InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy *messageHandlerProxy)
371 {
372 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnTerminatedFunc(messageHandlerProxy, OnTerminatedFunc));
373 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnMessageFunc(messageHandlerProxy, OnMessageFunc));
374 }
375
TestGetMessageHandlerProxyMember(InputMethod_MessageHandlerProxy * messageHandlerProxy)376 void InputMethodMessageHandlerTest::TestGetMessageHandlerProxyMember(
377 InputMethod_MessageHandlerProxy *messageHandlerProxy)
378 {
379 OH_MessageHandlerProxy_OnTerminatedFunc onTerminatedFunc = nullptr;
380 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_GetOnTerminatedFunc(messageHandlerProxy, &onTerminatedFunc));
381 EXPECT_EQ(OnTerminatedFunc, onTerminatedFunc);
382
383 OH_MessageHandlerProxy_OnMessageFunc onMessageFunc = nullptr;
384 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_GetOnMessageFunc(messageHandlerProxy, &onMessageFunc));
385 EXPECT_EQ(OnMessageFunc, onMessageFunc);
386 }
387
388 /**
389 * @tc.name: testIMCSendMessage_001
390 * @tc.desc: IMC SendMessage, valid msgId and msgParam.
391 * @tc.type: FUNC
392 * @tc.require:
393 */
394 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_001, TestSize.Level0)
395 {
396 IMSA_HILOGI("IMC testIMCSendMessage_001 Test START");
397 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
398 auto ret = inputMethodController_->Attach(textListener_);
399 std::this_thread::sleep_for(std::chrono::seconds(1));
400 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
401 auto messageHandler = std::make_shared<MessageHandlerCallback>();
402 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
403 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
404
405 ArrayBuffer arrayBuffer;
406 arrayBuffer.msgId = "testMsgId";
407 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
408 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
409 ret = inputMethodController_->SendMessage(arrayBuffer);
410 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
411
412 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
413 InputMethodMessageHandlerTest::ResetParam();
414 }
415
416 /**
417 * @tc.name: testIMCSendMessage_002
418 * @tc.desc: IMC SendMessage, msgId and msgParam is 0.
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_002, TestSize.Level0)
423 {
424 IMSA_HILOGI("IMC testIMCSendMessage_002 Test START");
425 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
426 auto ret = inputMethodController_->Attach(textListener_);
427 std::this_thread::sleep_for(std::chrono::seconds(1));
428 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
429 auto messageHandler = std::make_shared<MessageHandlerCallback>();
430 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
431 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
432
433 ArrayBuffer arrayBuffer;
434 ret = inputMethodController_->SendMessage(arrayBuffer);
435 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
436 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
437 InputMethodMessageHandlerTest::ResetParam();
438 }
439
440 /**
441 * @tc.name: testIMCSendMessage_003
442 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is 0.
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_003, TestSize.Level0)
447 {
448 IMSA_HILOGI("IMC testIMCSendMessage_003 Test START");
449 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
450 auto ret = inputMethodController_->Attach(textListener_);
451 std::this_thread::sleep_for(std::chrono::seconds(1));
452 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
453 auto messageHandler = std::make_shared<MessageHandlerCallback>();
454 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
455 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
456
457 ArrayBuffer arrayBuffer;
458 arrayBuffer.msgId = "testMsgId";
459 ret = inputMethodController_->SendMessage(arrayBuffer);
460 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
461 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
462 InputMethodMessageHandlerTest::ResetParam();
463 }
464
465 /**
466 * @tc.name: testIMCSendMessage_004
467 * @tc.desc: IMC SendMessage, msgId is 0 and msgParam is valid.
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_004, TestSize.Level0)
472 {
473 IMSA_HILOGI("IMC testIMCSendMessage_004 Test START");
474 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
475 auto ret = inputMethodController_->Attach(textListener_);
476 std::this_thread::sleep_for(std::chrono::seconds(1));
477 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
478 auto messageHandler = std::make_shared<MessageHandlerCallback>();
479 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
480 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
481
482 ArrayBuffer arrayBuffer;
483 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
484 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
485 ret = inputMethodController_->SendMessage(arrayBuffer);
486 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
487 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
488 InputMethodMessageHandlerTest::ResetParam();
489 }
490
491 /**
492 * @tc.name: testIMCSendMessage_005
493 * @tc.desc: IMC SendMessage, msgId is max length and msgParam is valid.
494 * @tc.type: FUNC
495 * @tc.require:
496 */
497 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_005, TestSize.Level0)
498 {
499 IMSA_HILOGI("IMC testIMCSendMessage_005 Test START");
500 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
501 auto ret = inputMethodController_->Attach(textListener_);
502 std::this_thread::sleep_for(std::chrono::seconds(1));
503 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
504 auto messageHandler = std::make_shared<MessageHandlerCallback>();
505 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
506 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
507
508 ArrayBuffer arrayBuffer;
509 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE, 'a');
510 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
511 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
512 ret = inputMethodController_->SendMessage(arrayBuffer);
513 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
514 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
515 InputMethodMessageHandlerTest::ResetParam();
516 }
517
518 /**
519 * @tc.name: testIMCSendMessage_006
520 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is max length.
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_006, TestSize.Level0)
525 {
526 IMSA_HILOGI("IMC testIMCSendMessage_006 Test START");
527 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
528 auto ret = inputMethodController_->Attach(textListener_);
529 std::this_thread::sleep_for(std::chrono::seconds(1));
530 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
531 auto messageHandler = std::make_shared<MessageHandlerCallback>();
532 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
533 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
534
535 ArrayBuffer arrayBuffer;
536 arrayBuffer.msgId = "testMsgId";
537 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE, 'a');
538 ret = inputMethodController_->SendMessage(arrayBuffer);
539 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
540 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
541 InputMethodMessageHandlerTest::ResetParam();
542 }
543
544 /**
545 * @tc.name: testIMCSendMessage_007
546 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is exceeds max length.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_007, TestSize.Level0)
551 {
552 IMSA_HILOGI("IMC testIMCSendMessage_007 Test START");
553 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
554 auto ret = inputMethodController_->Attach(textListener_);
555 std::this_thread::sleep_for(std::chrono::seconds(1));
556 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
557 auto messageHandler = std::make_shared<MessageHandlerCallback>();
558 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
559 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
560
561 ArrayBuffer arrayBuffer;
562 arrayBuffer.msgId = "testMsgId";
563 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
564 ret = inputMethodController_->SendMessage(arrayBuffer);
565 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
566 InputMethodMessageHandlerTest::ResetParam();
567 }
568
569 /**
570 * @tc.name: testIMCSendMessage_008
571 * @tc.desc: IMC SendMessage, msgId is exceeds max length and msgParam is valid.
572 * @tc.type: FUNC
573 * @tc.require:
574 */
575 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_008, TestSize.Level0)
576 {
577 IMSA_HILOGI("IMC testIMCSendMessage_008 Test START");
578 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
579 auto ret = inputMethodController_->Attach(textListener_);
580 std::this_thread::sleep_for(std::chrono::seconds(1));
581 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
582 auto messageHandler = std::make_shared<MessageHandlerCallback>();
583 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
584 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
585
586 ArrayBuffer arrayBuffer;
587 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
588 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
589 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
590 ret = inputMethodController_->SendMessage(arrayBuffer);
591 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
592 InputMethodMessageHandlerTest::ResetParam();
593 }
594
595 /**
596 * @tc.name: testIMCSendMessage_009
597 * @tc.desc: IMC SendMessage, msgId and msgParam are all exceed max length.
598 * @tc.type: FUNC
599 * @tc.require:
600 */
601 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_009, TestSize.Level0)
602 {
603 IMSA_HILOGI("IMC testIMCSendMessage_009 Test START");
604 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
605 auto ret = inputMethodController_->Attach(textListener_);
606 std::this_thread::sleep_for(std::chrono::seconds(1));
607 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
608 auto messageHandler = std::make_shared<MessageHandlerCallback>();
609 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
610 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
611
612 ArrayBuffer arrayBuffer;
613 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
614 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
615 ret = inputMethodController_->SendMessage(arrayBuffer);
616 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
617 InputMethodMessageHandlerTest::ResetParam();
618 }
619
620 /**
621 * @tc.name: testIMCSendMessage_010
622 * @tc.desc: IMC SendMessage, without Attach.
623 * @tc.type: FUNC
624 * @tc.require:
625 */
626 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_010, TestSize.Level0)
627 {
628 IMSA_HILOGI("IMC testIMCSendMessage_010 Test START");
629 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
630 ArrayBuffer arrayBuffer;
631 arrayBuffer.msgId = "testMsgId";
632 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
633 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
634 auto ret = inputMethodController_->SendMessage(arrayBuffer);
635 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_BOUND);
636 InputMethodMessageHandlerTest::ResetParam();
637 }
638
639 /**
640 * @tc.name: testIMCSendMessage_011
641 * @tc.desc: IMC SendMessage, Attach but not editable.
642 * @tc.type: FUNC
643 * @tc.require:
644 */
645 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_011, TestSize.Level0)
646 {
647 IMSA_HILOGI("IMC testIMCSendMessage_011 Test START");
648 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
649 auto ret = inputMethodController_->Attach(textListener_);
650 std::this_thread::sleep_for(std::chrono::seconds(1));
651 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
652 auto messageHandler = std::make_shared<MessageHandlerCallback>();
653 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
654 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
655 inputMethodController_->isEditable_.store(false);
656
657 ArrayBuffer arrayBuffer;
658 arrayBuffer.msgId = "testMsgId";
659 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
660 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
661 ret = inputMethodController_->SendMessage(arrayBuffer);
662 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_EDITABLE);
663 InputMethodMessageHandlerTest::ResetParam();
664 }
665
666 /**
667 * @tc.name: testIMCSendMessage_012
668 * @tc.desc: IMC SendMessage, basic security mode.
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_012, TestSize.Level0)
673 {
674 IMSA_HILOGI("IMC testIMCSendMessage_012 Test START");
675 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::BASIC));
676 auto ret = inputMethodController_->Attach(textListener_);
677 std::this_thread::sleep_for(std::chrono::seconds(1));
678 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
679 auto messageHandler = std::make_shared<MessageHandlerCallback>();
680 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
681 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
682
683 ArrayBuffer arrayBuffer;
684 arrayBuffer.msgId = "testMsgId";
685 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
686 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
687 ret = inputMethodController_->SendMessage(arrayBuffer);
688 EXPECT_EQ(ret, ErrorCode::ERROR_SECURITY_MODE_OFF);
689
690 InputMethodMessageHandlerTest::ResetParam();
691 }
692
693
694 /**
695 * @tc.name: testIMCSendMessage_013
696 * @tc.desc: IMC SendMessage, without register message handler another side.
697 * @tc.type: FUNC
698 * @tc.require:
699 */
700 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_013, TestSize.Level0)
701 {
702 IMSA_HILOGI("IMC testIMCSendMessage_013 Test START");
703 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
704 auto ret = inputMethodController_->Attach(textListener_);
705 std::this_thread::sleep_for(std::chrono::seconds(1));
706 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
707
708 ArrayBuffer arrayBuffer;
709 arrayBuffer.msgId = "testMsgId";
710 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
711 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
712 ret = inputMethodController_->SendMessage(arrayBuffer);
713 EXPECT_EQ(ret, ErrorCode::ERROR_MSG_HANDLER_NOT_REGIST);
714
715 InputMethodMessageHandlerTest::ResetParam();
716 }
717
718 /**
719 * @tc.name: testIMCRegisterMsgHandler_001
720 * @tc.desc: IMA RegisterMsgHandler, duplicate registration will triggers ex-callback OnTerminated.
721 * @tc.type: FUNC
722 * @tc.require:
723 */
724 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_001, TestSize.Level0)
725 {
726 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_001 Test START");
727 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
728 auto messageHandler = std::make_shared<MessageHandlerCallback>();
729 auto ret = inputMethodAbility_->RegisterMsgHandler(exMessageHandler);
730 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
731 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
732
733 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
734 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
735 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
736 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
737
738 ret = inputMethodAbility_->RegisterMsgHandler(nullptr);
739 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
740 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
741 }
742
743 /**
744 * @tc.name: testIMCRegisterMsgHandler_002
745 * @tc.desc: IMA RegisterMsgHandler, message handler is globally unique.
746 * @tc.type: FUNC
747 * @tc.require:
748 */
749 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_002, TestSize.Level0)
750 {
751 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_002 Test START");
752 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
753 auto messageHandler = std::make_shared<MessageHandlerCallback>();
754 auto ret = inputMethodAbility_->RegisterMsgHandler(exMessageHandler);
755 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
756 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
757 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
758 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
759 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
760 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
761 messageHandler->ClearParam();
762 exMessageHandler->ClearParam();
763
764 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
765 ret = inputMethodController_->Attach(textListener_);
766 std::this_thread::sleep_for(std::chrono::seconds(1));
767 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
768 ArrayBuffer arrayBuffer;
769 arrayBuffer.msgId = "testMsgId";
770 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
771 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
772 ret = inputMethodController_->SendMessage(arrayBuffer);
773 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
774 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, true));
775 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
776 messageHandler->ClearParam();
777
778 ret = inputMethodAbility_->RegisterMsgHandler();
779 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
780 InputMethodMessageHandlerTest::ResetParam();
781 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
782 }
783
784 /**
785 * @tc.name: testIMCRegisterMsgHandler_003
786 * @tc.desc: IMA RegisterMsgHandler, unregister message handle will trigger OnTerminated.
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_003, TestSize.Level0)
791 {
792 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_003 Test START");
793 auto messageHandler = std::make_shared<MessageHandlerCallback>();
794 auto ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
795 ret = inputMethodAbility_->RegisterMsgHandler(nullptr);
796 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
797 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
798 }
799
800 /**
801 * @tc.name: testIMCRegisterMsgHandler_004
802 * @tc.desc: IMC RegisterMsgHandler, duplicate registration will triggers ex-callback OnTerminated.
803 * @tc.type: FUNC
804 * @tc.require:
805 */
806 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_004, TestSize.Level0)
807 {
808 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_004 Test START");
809 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
810 auto messageHandler = std::make_shared<MessageHandlerCallback>();
811 auto ret = inputMethodController_->RegisterMsgHandler(exMessageHandler);
812 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
813 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
814
815 ret = inputMethodController_->RegisterMsgHandler(messageHandler);
816 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
817 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
818 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
819
820 ret = inputMethodController_->RegisterMsgHandler(nullptr);
821 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
822 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
823 }
824
825 /**
826 * @tc.name: testIMCRegisterMsgHandler_005
827 * @tc.desc: IMC RegisterMsgHandler, message handler is globally unique.
828 * @tc.type: FUNC
829 * @tc.require:
830 */
831 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_005, TestSize.Level0)
832 {
833 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_005 Test START");
834 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
835 auto messageHandler = std::make_shared<MessageHandlerCallback>();
836 auto ret = inputMethodController_->RegisterMsgHandler(exMessageHandler);
837 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
838 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
839 ret = inputMethodController_->RegisterMsgHandler(messageHandler);
840 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
841 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
842 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
843
844 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
845 ret = inputMethodController_->Attach(textListener_);
846 std::this_thread::sleep_for(std::chrono::seconds(1));
847 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
848 ArrayBuffer arrayBuffer;
849 arrayBuffer.msgId = "testMsgId";
850 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
851 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
852 ret = inputMethodAbility_->SendMessage(arrayBuffer);
853 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
854 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, true));
855 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
856 InputMethodMessageHandlerTest::ResetParam();
857
858 ret = inputMethodController_->RegisterMsgHandler(nullptr);
859 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
860 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
861 }
862
863 /**
864 * @tc.name: testIMCRegisterMsgHandler_006
865 * @tc.desc: IMC RegisterMsgHandler, unregister message handle will trigger OnTerminated.
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_006, TestSize.Level0)
870 {
871 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_006 Test START");
872 auto messageHandler = std::make_shared<MessageHandlerCallback>();
873 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
874 ret = inputMethodController_->RegisterMsgHandler(nullptr);
875 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
876 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
877 }
878
879 /**
880 * @tc.name: testIMASendMessage_001
881 * @tc.desc: IMA SendMessage, valid msgId and msgParam.
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_001, TestSize.Level0)
886 {
887 IMSA_HILOGI("IMA testIMASendMessage_001 Test START");
888 auto messageHandler = std::make_shared<MessageHandlerCallback>();
889 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
890 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
891 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
892 ret = inputMethodController_->Attach(textListener_);
893 std::this_thread::sleep_for(std::chrono::seconds(1));
894 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
895
896 ArrayBuffer arrayBuffer;
897 arrayBuffer.msgId = "testMsgId";
898 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
899 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
900 ret = inputMethodAbility_->SendMessage(arrayBuffer);
901 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
902 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
903
904 InputMethodMessageHandlerTest::ResetParam();
905 ret = inputMethodController_->RegisterMsgHandler(nullptr);
906 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
907 }
908
909 /**
910 * @tc.name: testIMASendMessage_002
911 * @tc.desc: IMA SendMessage, msgId and msgParam is 0.
912 * @tc.type: FUNC
913 * @tc.require:
914 */
915 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_002, TestSize.Level0)
916 {
917 IMSA_HILOGI("IMA testIMASendMessage_002 Test START");
918 auto messageHandler = std::make_shared<MessageHandlerCallback>();
919 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
920 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
921 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
922 ret = inputMethodController_->Attach(textListener_);
923 std::this_thread::sleep_for(std::chrono::seconds(1));
924 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
925
926 ArrayBuffer arrayBuffer;
927 ret = inputMethodAbility_->SendMessage(arrayBuffer);
928 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
929 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
930
931 InputMethodMessageHandlerTest::ResetParam();
932 ret = inputMethodController_->RegisterMsgHandler(nullptr);
933 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
934 }
935
936 /**
937 * @tc.name: testIMASendMessage_003
938 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is 0.
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_003, TestSize.Level0)
943 {
944 IMSA_HILOGI("IMA testIMASendMessage_003 Test START");
945 auto messageHandler = std::make_shared<MessageHandlerCallback>();
946 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
947 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
948 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
949 ret = inputMethodController_->Attach(textListener_);
950 std::this_thread::sleep_for(std::chrono::seconds(1));
951 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
952
953 ArrayBuffer arrayBuffer;
954 arrayBuffer.msgId = "testMsgId";
955 ret = inputMethodAbility_->SendMessage(arrayBuffer);
956 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
957 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
958
959 InputMethodMessageHandlerTest::ResetParam();
960 ret = inputMethodController_->RegisterMsgHandler(nullptr);
961 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
962 }
963
964 /**
965 * @tc.name: testIMASendMessage_004
966 * @tc.desc: IMA SendMessage, msgId is 0 and msgParam is valid.
967 * @tc.type: FUNC
968 * @tc.require:
969 */
970 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_004, TestSize.Level0)
971 {
972 IMSA_HILOGI("IMA testIMASendMessage_004 Test START");
973 auto messageHandler = std::make_shared<MessageHandlerCallback>();
974 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
975 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
976 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
977 ret = inputMethodController_->Attach(textListener_);
978 std::this_thread::sleep_for(std::chrono::seconds(1));
979 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
980
981 ArrayBuffer arrayBuffer;
982 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
983 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
984 ret = inputMethodAbility_->SendMessage(arrayBuffer);
985 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
986 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
987
988 InputMethodMessageHandlerTest::ResetParam();
989 ret = inputMethodController_->RegisterMsgHandler(nullptr);
990 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
991 }
992
993 /**
994 * @tc.name: testIMASendMessage_005
995 * @tc.desc: IMA SendMessage, msgId is max length and msgParam is valid.
996 * @tc.type: FUNC
997 * @tc.require:
998 */
999 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_005, TestSize.Level0)
1000 {
1001 IMSA_HILOGI("IMA testIMASendMessage_005 Test START");
1002 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1003 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1004 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1005 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1006 ret = inputMethodController_->Attach(textListener_);
1007 std::this_thread::sleep_for(std::chrono::seconds(1));
1008 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1009
1010 ArrayBuffer arrayBuffer;
1011 arrayBuffer.msgId = string(MAX_ARRAY_BUFFER_MSG_ID_SIZE, 'a');
1012 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1013 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1014 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1015 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1016 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1017
1018 InputMethodMessageHandlerTest::ResetParam();
1019 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1020 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
1021 }
1022
1023 /**
1024 * @tc.name: testIMASendMessage_006
1025 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is max length.
1026 * @tc.type: FUNC
1027 * @tc.require:
1028 */
1029 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_006, TestSize.Level0)
1030 {
1031 IMSA_HILOGI("IMA testIMASendMessage_006 Test START");
1032 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1033 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1034 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1035 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1036 ret = inputMethodController_->Attach(textListener_);
1037 std::this_thread::sleep_for(std::chrono::seconds(1));
1038 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1039
1040 ArrayBuffer arrayBuffer;
1041 arrayBuffer.msgId = "testMsgId";
1042 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE, 'a');
1043 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1044 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1045 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1046
1047 InputMethodMessageHandlerTest::ResetParam();
1048 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1049 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
1050 }
1051
1052 /**
1053 * @tc.name: testIMASendMessage_007
1054 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is exceeds max length.
1055 * @tc.type: FUNC
1056 * @tc.require:
1057 */
1058 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_007, TestSize.Level0)
1059 {
1060 IMSA_HILOGI("IMA testIMASendMessage_007 Test START");
1061 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1062 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1063 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1064 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1065 ret = inputMethodController_->Attach(textListener_);
1066 std::this_thread::sleep_for(std::chrono::seconds(1));
1067 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1068
1069 ArrayBuffer arrayBuffer;
1070 arrayBuffer.msgId = "testMsgId";
1071 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1072 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1073 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1074
1075 InputMethodMessageHandlerTest::ResetParam();
1076 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1077 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1078 }
1079
1080 /**
1081 * @tc.name: testIMASendMessage_008
1082 * @tc.desc: IMA SendMessage, msgId is exceeds max length and msgParam is valid.
1083 * @tc.type: FUNC
1084 * @tc.require:
1085 */
1086 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_008, TestSize.Level0)
1087 {
1088 IMSA_HILOGI("IMA testIMASendMessage_008 Test START");
1089 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1090 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1091 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1092 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1093 ret = inputMethodController_->Attach(textListener_);
1094 std::this_thread::sleep_for(std::chrono::seconds(1));
1095 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1096
1097 ArrayBuffer arrayBuffer;
1098 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1099 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1100 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1101 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1102 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1103
1104 InputMethodMessageHandlerTest::ResetParam();
1105 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1106 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1107 }
1108
1109 /**
1110 * @tc.name: testIMASendMessage_009
1111 * @tc.desc: IMA SendMessage, msgId and msgParam are all exceed max length.
1112 * @tc.type: FUNC
1113 * @tc.require:
1114 */
1115 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_009, TestSize.Level0)
1116 {
1117 IMSA_HILOGI("IMA testIMASendMessage_009 Test START");
1118 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1119 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1120 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1121 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1122 ret = inputMethodController_->Attach(textListener_);
1123 std::this_thread::sleep_for(std::chrono::seconds(1));
1124 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1125
1126 ArrayBuffer arrayBuffer;
1127 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1128 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1129 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1130 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1131 InputMethodMessageHandlerTest::ResetParam();
1132 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1133 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1134 }
1135
1136 /**
1137 * @tc.name: testIMASendMessage_010
1138 * @tc.desc: IMA SendMessage, without Attach.
1139 * @tc.type: FUNC
1140 * @tc.require:
1141 */
1142 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_010, TestSize.Level0)
1143 {
1144 IMSA_HILOGI("IMA testIMASendMessage_010 Test START");
1145 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1146 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1147 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1148 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1149
1150 ArrayBuffer arrayBuffer;
1151 arrayBuffer.msgId = "testMsgId";
1152 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1153 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1154 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1155 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
1156
1157 InputMethodMessageHandlerTest::ResetParam();
1158 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1159 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1160 }
1161
1162 /**
1163 * @tc.name: testIMASendMessage_011
1164 * @tc.desc: IMA SendMessage, Attach but not editable.
1165 * @tc.type: FUNC
1166 * @tc.require:
1167 */
1168 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_011, TestSize.Level0)
1169 {
1170 IMSA_HILOGI("IMA testIMASendMessage_011 Test START");
1171 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1172 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1173 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1174 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1175 ret = inputMethodController_->Attach(textListener_);
1176 std::this_thread::sleep_for(std::chrono::seconds(1));
1177 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1178 inputMethodController_->isEditable_.store(false);
1179
1180 ArrayBuffer arrayBuffer;
1181 arrayBuffer.msgId = "testMsgId";
1182 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1183 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1184 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1185 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_EDITABLE);
1186
1187 InputMethodMessageHandlerTest::ResetParam();
1188 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1189 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1190 }
1191
1192 /**
1193 * @tc.name: testIMASendMessage_012
1194 * @tc.desc: IMA SendMessage, another size was not registered message handler.
1195 * @tc.type: FUNC
1196 * @tc.require:
1197 */
1198 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_012, TestSize.Level0)
1199 {
1200 IMSA_HILOGI("IMA testIMASendMessage_012 Test START");
1201 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1202 auto ret = inputMethodController_->Attach(textListener_);
1203 std::this_thread::sleep_for(std::chrono::seconds(1));
1204 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1205
1206 ArrayBuffer arrayBuffer;
1207 arrayBuffer.msgId = "testMsgId";
1208 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1209 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1210 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1211 EXPECT_EQ(ret, ErrorCode::ERROR_MSG_HANDLER_NOT_REGIST);
1212
1213 InputMethodMessageHandlerTest::ResetParam();
1214 }
1215
1216 /**
1217 * @tc.name: testIMASendMessage_013
1218 * @tc.desc: IMA SendMessage, basic security mode.
1219 * @tc.type: FUNC
1220 * @tc.require:
1221 */
1222 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_013, TestSize.Level0)
1223 {
1224 IMSA_HILOGI("IMA testIMASendMessage_013 Test START");
1225 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1226 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1227 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1228 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::BASIC));
1229 ret = inputMethodController_->Attach(textListener_);
1230 std::this_thread::sleep_for(std::chrono::seconds(1));
1231 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1232
1233 ArrayBuffer arrayBuffer;
1234 arrayBuffer.msgId = "testMsgId";
1235 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1236 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1237 ret = inputMethodAbility_->SendMessage(arrayBuffer);
1238 EXPECT_EQ(ret, ErrorCode::ERROR_SECURITY_MODE_OFF);
1239
1240 InputMethodMessageHandlerTest::ResetParam();
1241 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1242 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1243 }
1244
1245 /**
1246 * @tc.name: testCallbackTiming_001
1247 * @tc.desc: IMC SendMessage, the message handler deliver timing, IMC to IMA.
1248 * @tc.type: FUNC
1249 * @tc.require:
1250 */
1251 HWTEST_F(InputMethodMessageHandlerTest, testCallbackTiming_001, TestSize.Level0)
1252 {
1253 ArrayBuffer arrayBufferA;
1254 arrayBufferA.msgId = "msgIdA";
1255 string msgParamA = "testParamAtestParamAtestParamAtestParamAtestParamA";
1256 arrayBufferA.msgParam.assign(msgParamA.begin(), msgParamA.end());
1257 ArrayBuffer arrayBufferB;
1258 arrayBufferB.msgId = "msgIdB";
1259 string msgParamB = "testParamAtestParamAtestParamAtestParamAtestParamB";
1260 arrayBufferB.msgParam.assign(msgParamB.begin(), msgParamB.end());
1261 ArrayBuffer arrayBufferC;
1262 arrayBufferC.msgId = "msgIdC";
1263 string msgParamC = "testParamAtestParamAtestParamAtestParamAtestParamC";
1264 arrayBufferC.msgParam.assign(msgParamC.begin(), msgParamC.end());
1265
1266 ArrayBuffer arrayBuffer;
1267 arrayBuffer.msgId = arrayBufferA.msgId + arrayBufferB.msgId + arrayBufferC.msgId;
1268 string msgParam = msgParamA + msgParamB + msgParamC;
1269 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1270
1271
1272 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1273 auto ret = inputMethodController_->Attach(textListener_);
1274 std::this_thread::sleep_for(std::chrono::seconds(1));
1275 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1276 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1277 ret = inputMethodAbility_->RegisterMsgHandler(messageHandler);
1278 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1279
1280 ret = inputMethodController_->SendMessage(arrayBufferA);
1281 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1282 ret = inputMethodController_->SendMessage(arrayBufferB);
1283 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1284 ret = inputMethodController_->SendMessage(arrayBufferC);
1285 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1286
1287 EXPECT_EQ(MessageHandlerCallback::GetTimingArrayBuffer(), arrayBuffer);
1288 InputMethodMessageHandlerTest::ResetParam();
1289 }
1290
1291 /**
1292 * @tc.name: textMessageHandlerProxy_001
1293 * @tc.desc: create and destroy MessageHandlerProxy success
1294 * @tc.type: FUNC
1295 * @tc.require:
1296 */
1297 HWTEST_F(InputMethodMessageHandlerTest, textMessageHandlerProxy_001, TestSize.Level0)
1298 {
1299 IMSA_HILOGI("Capi textMessageHandlerProxy_001 Test START");
1300 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1301 ASSERT_NE(nullptr, messageHanlderProxy);
1302 InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(messageHanlderProxy);
1303 InputMethodMessageHandlerTest::TestGetMessageHandlerProxyMember(messageHanlderProxy);
1304 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1305 }
1306
1307 /**
1308 * @tc.name: testSendMessageCapi_001
1309 * @tc.desc: input parameters invalid.
1310 * @tc.type: FUNC
1311 * @tc.require:
1312 */
1313 HWTEST_F(InputMethodMessageHandlerTest, testSendMessageCapi_001, TestSize.Level0)
1314 {
1315 IMSA_HILOGI("Capi testSendMessageCapi_001 Test START");
1316 InputMethod_InputMethodProxy *imeProxy = nullptr;
1317 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1318 EXPECT_EQ(ret, IME_ERR_OK);
1319 ASSERT_NE(nullptr, imeProxy);
1320
1321 std::u16string msgIdStr = u"msgId";
1322 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1323 vector<uint8_t> msgParam(msgParamStr.begin(), msgParamStr.end());
1324
1325 std::u16string msgIdStrOverSize(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1326 vector<uint8_t> msgParamOverSize(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1327
1328 ret = OH_InputMethodProxy_SendMessage(nullptr,
1329 msgIdStr.c_str(), msgIdStr.length(), msgParam.data(), msgParam.size());
1330 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1331 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1332 nullptr, msgIdStr.length(), msgParam.data(), msgParam.size());
1333 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1334 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1335 msgIdStr.c_str(), msgIdStr.length(), nullptr, msgParam.size());
1336 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1337
1338 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1339 msgIdStrOverSize.c_str(), msgIdStrOverSize.length(), msgParam.data(), msgParam.size());
1340 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1341 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1342 msgIdStr.c_str(), msgIdStr.length(), msgParamOverSize.data(), msgParamOverSize.size());
1343 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1344 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1345 msgIdStrOverSize.c_str(), msgIdStrOverSize.length(), msgParamOverSize.data(), msgParamOverSize.size());
1346 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1347
1348 ret = OH_InputMethodController_Detach(imeProxy);
1349 EXPECT_EQ(ret, IME_ERR_OK);
1350 InputMethodMessageHandlerTest::ResetParam();
1351 }
1352
1353 /**
1354 * @tc.name: testSendMessageCapi_002
1355 * @tc.desc: input valid parameters.
1356 * @tc.type: FUNC
1357 * @tc.require:
1358 */
1359 HWTEST_F(InputMethodMessageHandlerTest, testSendMessageCapi_002, TestSize.Level0)
1360 {
1361 IMSA_HILOGI("Capi testSendMessageCapi_002 Test START");
1362 InputMethod_InputMethodProxy *imeProxy = nullptr;
1363 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1364 EXPECT_EQ(ret, IME_ERR_OK);
1365 ASSERT_NE(nullptr, imeProxy);
1366 std::this_thread::sleep_for(std::chrono::seconds(1));
1367 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1368 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1369 auto res = inputMethodAbility_->RegisterMsgHandler(messageHandler);
1370 EXPECT_EQ(res, ErrorCode::NO_ERROR);
1371
1372 ArrayBuffer arrayBuffer;
1373 arrayBuffer.msgId = "msgId";
1374 std::u16string msgIdStr = Str8ToStr16(arrayBuffer.msgId);
1375 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1376 arrayBuffer.msgParam.assign(msgParamStr.begin(), msgParamStr.end());
1377
1378 ret = OH_InputMethodProxy_SendMessage(
1379 imeProxy, msgIdStr.c_str(), msgIdStr.length(), arrayBuffer.msgParam.data(), msgParamStr.size());
1380 EXPECT_EQ(ret, IME_ERR_OK);
1381
1382 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1383 ret = OH_InputMethodController_Detach(imeProxy);
1384 EXPECT_EQ(ret, IME_ERR_OK);
1385 InputMethodMessageHandlerTest::ResetParam();
1386 res = inputMethodAbility_->RegisterMsgHandler();
1387 EXPECT_EQ(res, ErrorCode::NO_ERROR);
1388 }
1389
1390 /**
1391 * @tc.name: testRecvMessageCapi_001
1392 * @tc.desc: register inputmethod message handler with invalid param.
1393 * @tc.type: FUNC
1394 * @tc.require:
1395 */
1396 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_001, TestSize.Level0)
1397 {
1398 IMSA_HILOGI("Capi testRecvMessageCapi_001 Test START");
1399 InputMethod_InputMethodProxy *imeProxy = nullptr;
1400 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1401 EXPECT_EQ(ret, IME_ERR_OK);
1402 ASSERT_NE(nullptr, imeProxy);
1403
1404 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1405 ASSERT_NE(nullptr, messageHanlderProxy);
1406 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy);
1407 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1408
1409 InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(messageHanlderProxy);
1410 ret = OH_InputMethodProxy_RecvMessage(nullptr, messageHanlderProxy);
1411 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1412
1413 ret = OH_InputMethodController_Detach(imeProxy);
1414 EXPECT_EQ(ret, IME_ERR_OK);
1415 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1416 InputMethodMessageHandlerTest::ResetParam();
1417 }
1418
1419 /**
1420 * @tc.name: testRecvMessageCapi_002
1421 * @tc.desc: register inputmethod message handler with valid param.
1422 * @tc.type: FUNC
1423 * @tc.require:
1424 */
1425 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_002, TestSize.Level0)
1426 {
1427 IMSA_HILOGI("Capi testRecvMessageCapi_002 Test START");
1428 InputMethod_InputMethodProxy *imeProxy = nullptr;
1429 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1430 EXPECT_EQ(ret, IME_ERR_OK);
1431 ASSERT_NE(nullptr, imeProxy);
1432
1433 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1434 EXPECT_EQ(ret, IME_ERR_OK);
1435
1436 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1437 EXPECT_EQ(ret, IME_ERR_OK);
1438 ret = OH_InputMethodController_Detach(imeProxy);
1439 EXPECT_EQ(ret, IME_ERR_OK);
1440 InputMethodMessageHandlerTest::ResetParam();
1441 }
1442
1443 /**
1444 * @tc.name: testRecvMessageCapi_003
1445 * @tc.desc: register another inputmethod message handler, will triiger exMessage handler OnTerminated.
1446 * @tc.type: FUNC
1447 * @tc.require:
1448 */
1449 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_003, TestSize.Level0)
1450 {
1451 IMSA_HILOGI("Capi testRecvMessageCapi_003 Test START");
1452 InputMethod_InputMethodProxy *imeProxy = nullptr;
1453 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1454 EXPECT_EQ(ret, IME_ERR_OK);
1455 ASSERT_NE(nullptr, imeProxy);
1456
1457 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1458 EXPECT_EQ(ret, IME_ERR_OK);
1459 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1460 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnTerminatedFunc(messageHanlderProxy, OnTerminatedFuncNew));
1461 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnMessageFunc(messageHanlderProxy, OnMessageFunc));
1462 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy);
1463 EXPECT_EQ(ret, IME_ERR_OK);
1464 EXPECT_TRUE(g_onTerminated);
1465 EXPECT_FALSE(g_onMessage);
1466 EXPECT_FALSE(g_onTerminatedNew);
1467
1468 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1469 EXPECT_EQ(ret, IME_ERR_OK);
1470 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1471 ret = OH_InputMethodController_Detach(imeProxy);
1472 EXPECT_EQ(ret, IME_ERR_OK);
1473 InputMethodMessageHandlerTest::ResetParam();
1474 }
1475
1476 /**
1477 * @tc.name: testMessageHandelrCallbackCapi_001
1478 * @tc.desc: recv message handler from ima.
1479 * @tc.type: FUNC
1480 * @tc.require:
1481 */
1482 HWTEST_F(InputMethodMessageHandlerTest, testMessageHandelrCallbackCapi_001, TestSize.Level0)
1483 {
1484 IMSA_HILOGI("Capi testMessageHandelrCallbackCapi_001 Test START");
1485 InputMethod_InputMethodProxy *imeProxy = nullptr;
1486 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1487 EXPECT_EQ(ret, IME_ERR_OK);
1488 ASSERT_NE(nullptr, imeProxy);
1489 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1490 EXPECT_EQ(ret, IME_ERR_OK);
1491 std::this_thread::sleep_for(std::chrono::seconds(1));
1492 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1493
1494 ArrayBuffer arrayBuffer;
1495 arrayBuffer.msgId = "msgId";
1496 std::u16string msgIdStr = Str8ToStr16(arrayBuffer.msgId);
1497 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1498 arrayBuffer.msgParam.assign(msgParamStr.begin(), msgParamStr.end());
1499 EXPECT_EQ(inputMethodAbility_->SendMessage(arrayBuffer), ErrorCode::NO_ERROR);
1500 EXPECT_TRUE(WaitOnMessageFunc(arrayBuffer));
1501
1502 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1503 EXPECT_EQ(ret, IME_ERR_OK);
1504 ret = OH_InputMethodController_Detach(imeProxy);
1505 EXPECT_EQ(ret, IME_ERR_OK);
1506 InputMethodMessageHandlerTest::ResetParam();
1507 }
1508 } // namespace MiscServices
1509 } // namespace OHOS