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 "iinput_method_agent.h"
38 #include "iinput_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_system_ability_proxy.h"
46 #include "input_method_engine_listener_impl.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 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 InputMethodAbility &InputMethodMessageHandlerTest::inputMethodAbility_ = InputMethodAbility::GetInstance();
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_.abilityManager_ = imsaProxy_;
286 textListener_ = new TextListener();
287 TddUtil::InitCurrentImePermissionInfo();
288 IdentityCheckerMock::SetBundleName(TddUtil::currentBundleNameMock_);
289 inputMethodAbility_.SetCoreAndAgent();
290 imeListener_ = std::make_shared<InputMethodEngineListenerImpl>(textConfigHandler_);
291 inputMethodAbility_.SetImeListener(imeListener_);
292
293 inputMethodController_ = InputMethodController::GetInstance();
294 inputMethodController_->abilityManager_ = imsaProxy_;
295
296 option_ = OH_AttachOptions_Create(true);
297 textEditorProxy_ = OH_TextEditorProxy_Create();
298 ConstructTextEditorProxy(textEditorProxy_);
299 messageHanlderProxy_ = OH_MessageHandlerProxy_Create();
300 ConstructMessageHandlerProxy(messageHanlderProxy_);
301 }
302
TearDownTestCase(void)303 void InputMethodMessageHandlerTest::TearDownTestCase(void)
304 {
305 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDownTestCase");
306 inputMethodController_->SetControllerListener(nullptr);
307 IdentityCheckerMock::ResetParam();
308 imsa_->OnStop();
309 OH_AttachOptions_Destroy(option_);
310 OH_TextEditorProxy_Destroy(textEditorProxy_);
311 OH_MessageHandlerProxy_Destroy(messageHanlderProxy_);
312 }
313
SetUp(void)314 void InputMethodMessageHandlerTest::SetUp(void)
315 {
316 IMSA_HILOGI("InputMethodMessageHandlerTest::SetUp");
317 TaskManager::GetInstance().SetInited(true);
318 }
319
TearDown(void)320 void InputMethodMessageHandlerTest::TearDown(void)
321 {
322 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDown");
323 std::this_thread::sleep_for(std::chrono::seconds(1));
324 TaskManager::GetInstance().Reset();
325 ResetParam();
326 }
327
SetSecurityModeEnable(int32_t securityMode)328 void InputMethodMessageHandlerTest::SetSecurityModeEnable(int32_t securityMode)
329 {
330 inputMethodAbility_.securityMode_.store(securityMode);
331 }
332
ResetParam()333 void InputMethodMessageHandlerTest::ResetParam()
334 {
335 inputMethodController_->Close();
336 inputMethodAbility_.securityMode_.store(-1);
337 InputMethodEngineListenerImpl::ResetParam();
338 MessageHandlerCallback::ClearArrayBuffer();
339 inputMethodAbility_.RegisterMsgHandler();
340 inputMethodController_->RegisterMsgHandler();
341 g_onTerminated = false;
342 g_onMessage = false;
343 g_onTerminatedNew = false;
344 }
345
ConstructTextEditorProxy(InputMethod_TextEditorProxy * textEditorProxy)346 void InputMethodMessageHandlerTest::ConstructTextEditorProxy(InputMethod_TextEditorProxy *textEditorProxy)
347 {
348 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetTextConfigFunc(textEditorProxy, GetTextConfigFunc));
349 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetInsertTextFunc(textEditorProxy, InsertTextFunc));
350 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetDeleteForwardFunc(textEditorProxy, DeleteForwardFunc));
351 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetDeleteBackwardFunc(textEditorProxy, DeleteBackwardFunc));
352 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSendKeyboardStatusFunc(textEditorProxy, SendKeyboardStatusFunc));
353 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSendEnterKeyFunc(textEditorProxy, SendEnterKeyFunc));
354 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetMoveCursorFunc(textEditorProxy, MoveCursorFunc));
355 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetHandleSetSelectionFunc(textEditorProxy, HandleSetSelectionFunc));
356 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetHandleExtendActionFunc(textEditorProxy, HandleExtendActionFunc));
357 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetLeftTextOfCursorFunc(textEditorProxy, GetleftTextOfCursorFunc));
358 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetRightTextOfCursorFunc(textEditorProxy, GetRightTextOfCursorFunc));
359 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetGetTextIndexAtCursorFunc(textEditorProxy, GetTextIndexAtCursorFunc));
360 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetReceivePrivateCommandFunc(textEditorProxy, ReceivePrivateCommandFunc));
361 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetSetPreviewTextFunc(textEditorProxy, SetPreviewTextFunc));
362 EXPECT_EQ(IME_ERR_OK, OH_TextEditorProxy_SetFinishTextPreviewFunc(textEditorProxy, FinishTextPreviewFunc));
363 }
364
ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy * messageHandlerProxy)365 void InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy *messageHandlerProxy)
366 {
367 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnTerminatedFunc(messageHandlerProxy, OnTerminatedFunc));
368 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnMessageFunc(messageHandlerProxy, OnMessageFunc));
369 }
370
TestGetMessageHandlerProxyMember(InputMethod_MessageHandlerProxy * messageHandlerProxy)371 void InputMethodMessageHandlerTest::TestGetMessageHandlerProxyMember(
372 InputMethod_MessageHandlerProxy *messageHandlerProxy)
373 {
374 OH_MessageHandlerProxy_OnTerminatedFunc onTerminatedFunc = nullptr;
375 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_GetOnTerminatedFunc(messageHandlerProxy, &onTerminatedFunc));
376 EXPECT_EQ(OnTerminatedFunc, onTerminatedFunc);
377
378 OH_MessageHandlerProxy_OnMessageFunc onMessageFunc = nullptr;
379 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_GetOnMessageFunc(messageHandlerProxy, &onMessageFunc));
380 EXPECT_EQ(OnMessageFunc, onMessageFunc);
381 }
382
383 /**
384 * @tc.name: testIMCSendMessage_001
385 * @tc.desc: IMC SendMessage, valid msgId and msgParam.
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_001, TestSize.Level1)
390 {
391 IMSA_HILOGI("IMC testIMCSendMessage_001 Test START");
392 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
393 auto ret = inputMethodController_->Attach(textListener_);
394 std::this_thread::sleep_for(std::chrono::seconds(1));
395 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
396 auto messageHandler = std::make_shared<MessageHandlerCallback>();
397 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
398 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
399
400 ArrayBuffer arrayBuffer;
401 arrayBuffer.msgId = "testMsgId";
402 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
403 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
404 ret = inputMethodController_->SendMessage(arrayBuffer);
405 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
406
407 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
408 InputMethodMessageHandlerTest::ResetParam();
409 }
410
411 /**
412 * @tc.name: testIMCSendMessage_002
413 * @tc.desc: IMC SendMessage, msgId and msgParam is 0.
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_002, TestSize.Level1)
418 {
419 IMSA_HILOGI("IMC testIMCSendMessage_002 Test START");
420 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
421 auto ret = inputMethodController_->Attach(textListener_);
422 std::this_thread::sleep_for(std::chrono::seconds(1));
423 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
424 auto messageHandler = std::make_shared<MessageHandlerCallback>();
425 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
426 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
427
428 ArrayBuffer arrayBuffer;
429 ret = inputMethodController_->SendMessage(arrayBuffer);
430 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
431 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
432 InputMethodMessageHandlerTest::ResetParam();
433 }
434
435 /**
436 * @tc.name: testIMCSendMessage_003
437 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is 0.
438 * @tc.type: FUNC
439 * @tc.require:
440 */
441 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_003, TestSize.Level1)
442 {
443 IMSA_HILOGI("IMC testIMCSendMessage_003 Test START");
444 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
445 auto ret = inputMethodController_->Attach(textListener_);
446 std::this_thread::sleep_for(std::chrono::seconds(1));
447 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
448 auto messageHandler = std::make_shared<MessageHandlerCallback>();
449 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
450 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
451
452 ArrayBuffer arrayBuffer;
453 arrayBuffer.msgId = "testMsgId";
454 ret = inputMethodController_->SendMessage(arrayBuffer);
455 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
456 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
457 InputMethodMessageHandlerTest::ResetParam();
458 }
459
460 /**
461 * @tc.name: testIMCSendMessage_004
462 * @tc.desc: IMC SendMessage, msgId is 0 and msgParam is valid.
463 * @tc.type: FUNC
464 * @tc.require:
465 */
466 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_004, TestSize.Level1)
467 {
468 IMSA_HILOGI("IMC testIMCSendMessage_004 Test START");
469 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
470 auto ret = inputMethodController_->Attach(textListener_);
471 std::this_thread::sleep_for(std::chrono::seconds(1));
472 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
473 auto messageHandler = std::make_shared<MessageHandlerCallback>();
474 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
475 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
476
477 ArrayBuffer arrayBuffer;
478 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
479 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
480 ret = inputMethodController_->SendMessage(arrayBuffer);
481 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
482 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
483 InputMethodMessageHandlerTest::ResetParam();
484 }
485
486 /**
487 * @tc.name: testIMCSendMessage_005
488 * @tc.desc: IMC SendMessage, msgId is max length and msgParam is valid.
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_005, TestSize.Level1)
493 {
494 IMSA_HILOGI("IMC testIMCSendMessage_005 Test START");
495 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
496 auto ret = inputMethodController_->Attach(textListener_);
497 std::this_thread::sleep_for(std::chrono::seconds(1));
498 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
499 auto messageHandler = std::make_shared<MessageHandlerCallback>();
500 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
501 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
502
503 ArrayBuffer arrayBuffer;
504 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE, 'a');
505 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
506 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
507 ret = inputMethodController_->SendMessage(arrayBuffer);
508 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
509 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
510 InputMethodMessageHandlerTest::ResetParam();
511 }
512
513 /**
514 * @tc.name: testIMCSendMessage_006
515 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is max length.
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_006, TestSize.Level1)
520 {
521 IMSA_HILOGI("IMC testIMCSendMessage_006 Test START");
522 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
523 auto ret = inputMethodController_->Attach(textListener_);
524 std::this_thread::sleep_for(std::chrono::seconds(1));
525 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
526 auto messageHandler = std::make_shared<MessageHandlerCallback>();
527 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
528 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
529
530 ArrayBuffer arrayBuffer;
531 arrayBuffer.msgId = "testMsgId";
532 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE, 'a');
533 ret = inputMethodController_->SendMessage(arrayBuffer);
534 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
535 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
536 InputMethodMessageHandlerTest::ResetParam();
537 }
538
539 /**
540 * @tc.name: testIMCSendMessage_007
541 * @tc.desc: IMC SendMessage, msgId is valid and msgParam is exceeds max length.
542 * @tc.type: FUNC
543 * @tc.require:
544 */
545 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_007, TestSize.Level1)
546 {
547 IMSA_HILOGI("IMC testIMCSendMessage_007 Test START");
548 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
549 auto ret = inputMethodController_->Attach(textListener_);
550 std::this_thread::sleep_for(std::chrono::seconds(1));
551 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
552 auto messageHandler = std::make_shared<MessageHandlerCallback>();
553 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
554 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
555
556 ArrayBuffer arrayBuffer;
557 arrayBuffer.msgId = "testMsgId";
558 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
559 ret = inputMethodController_->SendMessage(arrayBuffer);
560 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
561 InputMethodMessageHandlerTest::ResetParam();
562 }
563
564 /**
565 * @tc.name: testIMCSendMessage_008
566 * @tc.desc: IMC SendMessage, msgId is exceeds max length and msgParam is valid.
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_008, TestSize.Level1)
571 {
572 IMSA_HILOGI("IMC testIMCSendMessage_008 Test START");
573 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
574 auto ret = inputMethodController_->Attach(textListener_);
575 std::this_thread::sleep_for(std::chrono::seconds(1));
576 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
577 auto messageHandler = std::make_shared<MessageHandlerCallback>();
578 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
579 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
580
581 ArrayBuffer arrayBuffer;
582 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
583 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
584 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
585 ret = inputMethodController_->SendMessage(arrayBuffer);
586 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
587 InputMethodMessageHandlerTest::ResetParam();
588 }
589
590 /**
591 * @tc.name: testIMCSendMessage_009
592 * @tc.desc: IMC SendMessage, msgId and msgParam are all exceed max length.
593 * @tc.type: FUNC
594 * @tc.require:
595 */
596 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_009, TestSize.Level1)
597 {
598 IMSA_HILOGI("IMC testIMCSendMessage_009 Test START");
599 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
600 auto ret = inputMethodController_->Attach(textListener_);
601 std::this_thread::sleep_for(std::chrono::seconds(1));
602 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
603 auto messageHandler = std::make_shared<MessageHandlerCallback>();
604 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
605 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
606
607 ArrayBuffer arrayBuffer;
608 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
609 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
610 ret = inputMethodController_->SendMessage(arrayBuffer);
611 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
612 InputMethodMessageHandlerTest::ResetParam();
613 }
614
615 /**
616 * @tc.name: testIMCSendMessage_010
617 * @tc.desc: IMC SendMessage, without Attach.
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_010, TestSize.Level1)
622 {
623 IMSA_HILOGI("IMC testIMCSendMessage_010 Test START");
624 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
625 ArrayBuffer arrayBuffer;
626 arrayBuffer.msgId = "testMsgId";
627 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
628 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
629 auto ret = inputMethodController_->SendMessage(arrayBuffer);
630 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_BOUND);
631 InputMethodMessageHandlerTest::ResetParam();
632 }
633
634 /**
635 * @tc.name: testIMCSendMessage_011
636 * @tc.desc: IMC SendMessage, Attach but not editable.
637 * @tc.type: FUNC
638 * @tc.require:
639 */
640 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_011, TestSize.Level1)
641 {
642 IMSA_HILOGI("IMC testIMCSendMessage_011 Test START");
643 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
644 auto ret = inputMethodController_->Attach(textListener_);
645 std::this_thread::sleep_for(std::chrono::seconds(1));
646 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
647 auto messageHandler = std::make_shared<MessageHandlerCallback>();
648 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
649 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
650 inputMethodController_->isEditable_.store(false);
651
652 ArrayBuffer arrayBuffer;
653 arrayBuffer.msgId = "testMsgId";
654 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
655 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
656 ret = inputMethodController_->SendMessage(arrayBuffer);
657 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_EDITABLE);
658 InputMethodMessageHandlerTest::ResetParam();
659 }
660
661 /**
662 * @tc.name: testIMCSendMessage_012
663 * @tc.desc: IMC SendMessage, basic security mode.
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_012, TestSize.Level1)
668 {
669 IMSA_HILOGI("IMC testIMCSendMessage_012 Test START");
670 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::BASIC));
671 auto ret = inputMethodController_->Attach(textListener_);
672 std::this_thread::sleep_for(std::chrono::seconds(1));
673 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
674 auto messageHandler = std::make_shared<MessageHandlerCallback>();
675 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
676 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
677
678 ArrayBuffer arrayBuffer;
679 arrayBuffer.msgId = "testMsgId";
680 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
681 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
682 ret = inputMethodController_->SendMessage(arrayBuffer);
683 EXPECT_EQ(ret, ErrorCode::ERROR_SECURITY_MODE_OFF);
684
685 InputMethodMessageHandlerTest::ResetParam();
686 }
687
688
689 /**
690 * @tc.name: testIMCSendMessage_013
691 * @tc.desc: IMC SendMessage, without register message handler another side.
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(InputMethodMessageHandlerTest, testIMCSendMessage_013, TestSize.Level1)
696 {
697 IMSA_HILOGI("IMC testIMCSendMessage_013 Test START");
698 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
699 auto ret = inputMethodController_->Attach(textListener_);
700 std::this_thread::sleep_for(std::chrono::seconds(1));
701 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
702
703 ArrayBuffer arrayBuffer;
704 arrayBuffer.msgId = "testMsgId";
705 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
706 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
707 ret = inputMethodController_->SendMessage(arrayBuffer);
708 EXPECT_EQ(ret, ErrorCode::ERROR_MSG_HANDLER_NOT_REGIST);
709
710 InputMethodMessageHandlerTest::ResetParam();
711 }
712
713 /**
714 * @tc.name: testIMCRegisterMsgHandler_001
715 * @tc.desc: IMA RegisterMsgHandler, duplicate registration will triggers ex-callback OnTerminated.
716 * @tc.type: FUNC
717 * @tc.require:
718 */
719 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_001, TestSize.Level1)
720 {
721 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_001 Test START");
722 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
723 auto messageHandler = std::make_shared<MessageHandlerCallback>();
724 auto ret = inputMethodAbility_.RegisterMsgHandler(exMessageHandler);
725 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
726 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
727
728 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
729 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
730 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
731 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
732
733 ret = inputMethodAbility_.RegisterMsgHandler(nullptr);
734 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
735 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
736 }
737
738 /**
739 * @tc.name: testIMCRegisterMsgHandler_002
740 * @tc.desc: IMA RegisterMsgHandler, message handler is globally unique.
741 * @tc.type: FUNC
742 * @tc.require:
743 */
744 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_002, TestSize.Level1)
745 {
746 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_002 Test START");
747 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
748 auto messageHandler = std::make_shared<MessageHandlerCallback>();
749 auto ret = inputMethodAbility_.RegisterMsgHandler(exMessageHandler);
750 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
751 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
752 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
753 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
754 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
755 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
756 messageHandler->ClearParam();
757 exMessageHandler->ClearParam();
758
759 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
760 ret = inputMethodController_->Attach(textListener_);
761 std::this_thread::sleep_for(std::chrono::seconds(1));
762 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
763 ArrayBuffer arrayBuffer;
764 arrayBuffer.msgId = "testMsgId";
765 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
766 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
767 ret = inputMethodController_->SendMessage(arrayBuffer);
768 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
769 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, true));
770 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
771 messageHandler->ClearParam();
772
773 ret = inputMethodAbility_.RegisterMsgHandler();
774 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
775 InputMethodMessageHandlerTest::ResetParam();
776 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
777 }
778
779 /**
780 * @tc.name: testIMCRegisterMsgHandler_003
781 * @tc.desc: IMA RegisterMsgHandler, unregister message handle will trigger OnTerminated.
782 * @tc.type: FUNC
783 * @tc.require:
784 */
785 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_003, TestSize.Level1)
786 {
787 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_003 Test START");
788 auto messageHandler = std::make_shared<MessageHandlerCallback>();
789 auto ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
790 ret = inputMethodAbility_.RegisterMsgHandler(nullptr);
791 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
792 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
793 }
794
795 /**
796 * @tc.name: testIMCRegisterMsgHandler_004
797 * @tc.desc: IMC RegisterMsgHandler, duplicate registration will triggers ex-callback OnTerminated.
798 * @tc.type: FUNC
799 * @tc.require:
800 */
801 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_004, TestSize.Level1)
802 {
803 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_004 Test START");
804 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
805 auto messageHandler = std::make_shared<MessageHandlerCallback>();
806 auto ret = inputMethodController_->RegisterMsgHandler(exMessageHandler);
807 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
808 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
809
810 ret = inputMethodController_->RegisterMsgHandler(messageHandler);
811 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
812 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
813 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
814
815 ret = inputMethodController_->RegisterMsgHandler(nullptr);
816 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
817 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
818 }
819
820 /**
821 * @tc.name: testIMCRegisterMsgHandler_005
822 * @tc.desc: IMC RegisterMsgHandler, message handler is globally unique.
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_005, TestSize.Level1)
827 {
828 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_005 Test START");
829 auto exMessageHandler = std::make_shared<MessageHandlerCallback>();
830 auto messageHandler = std::make_shared<MessageHandlerCallback>();
831 auto ret = inputMethodController_->RegisterMsgHandler(exMessageHandler);
832 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
833 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(false, false));
834 ret = inputMethodController_->RegisterMsgHandler(messageHandler);
835 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
836 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, false));
837 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
838
839 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
840 ret = inputMethodController_->Attach(textListener_);
841 std::this_thread::sleep_for(std::chrono::seconds(1));
842 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
843 ArrayBuffer arrayBuffer;
844 arrayBuffer.msgId = "testMsgId";
845 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
846 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
847 ret = inputMethodAbility_.SendMessage(arrayBuffer);
848 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
849 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(false, true));
850 EXPECT_TRUE(exMessageHandler->CheckOnTerminatedAndOnMessage(true, false));
851 InputMethodMessageHandlerTest::ResetParam();
852
853 ret = inputMethodController_->RegisterMsgHandler(nullptr);
854 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
855 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
856 }
857
858 /**
859 * @tc.name: testIMCRegisterMsgHandler_006
860 * @tc.desc: IMC RegisterMsgHandler, unregister message handle will trigger OnTerminated.
861 * @tc.type: FUNC
862 * @tc.require:
863 */
864 HWTEST_F(InputMethodMessageHandlerTest, testIMCRegisterMsgHandler_006, TestSize.Level1)
865 {
866 IMSA_HILOGI("IMC testIMCRegisterMsgHandler_006 Test START");
867 auto messageHandler = std::make_shared<MessageHandlerCallback>();
868 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
869 ret = inputMethodController_->RegisterMsgHandler(nullptr);
870 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
871 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
872 }
873
874 /**
875 * @tc.name: testIMASendMessage_001
876 * @tc.desc: IMA SendMessage, valid msgId and msgParam.
877 * @tc.type: FUNC
878 * @tc.require:
879 */
880 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_001, TestSize.Level1)
881 {
882 IMSA_HILOGI("IMA testIMASendMessage_001 Test START");
883 auto messageHandler = std::make_shared<MessageHandlerCallback>();
884 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
885 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
886 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
887 ret = inputMethodController_->Attach(textListener_);
888 std::this_thread::sleep_for(std::chrono::seconds(1));
889 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
890
891 ArrayBuffer arrayBuffer;
892 arrayBuffer.msgId = "testMsgId";
893 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
894 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
895 ret = inputMethodAbility_.SendMessage(arrayBuffer);
896 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
897 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
898
899 InputMethodMessageHandlerTest::ResetParam();
900 ret = inputMethodController_->RegisterMsgHandler(nullptr);
901 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
902 }
903
904 /**
905 * @tc.name: testIMASendMessage_002
906 * @tc.desc: IMA SendMessage, msgId and msgParam is 0.
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_002, TestSize.Level1)
911 {
912 IMSA_HILOGI("IMA testIMASendMessage_002 Test START");
913 auto messageHandler = std::make_shared<MessageHandlerCallback>();
914 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
915 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
916 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
917 ret = inputMethodController_->Attach(textListener_);
918 std::this_thread::sleep_for(std::chrono::seconds(1));
919 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
920
921 ArrayBuffer arrayBuffer;
922 ret = inputMethodAbility_.SendMessage(arrayBuffer);
923 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
924 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
925
926 InputMethodMessageHandlerTest::ResetParam();
927 ret = inputMethodController_->RegisterMsgHandler(nullptr);
928 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
929 }
930
931 /**
932 * @tc.name: testIMASendMessage_003
933 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is 0.
934 * @tc.type: FUNC
935 * @tc.require:
936 */
937 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_003, TestSize.Level1)
938 {
939 IMSA_HILOGI("IMA testIMASendMessage_003 Test START");
940 auto messageHandler = std::make_shared<MessageHandlerCallback>();
941 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
942 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
943 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
944 ret = inputMethodController_->Attach(textListener_);
945 std::this_thread::sleep_for(std::chrono::seconds(1));
946 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
947
948 ArrayBuffer arrayBuffer;
949 arrayBuffer.msgId = "testMsgId";
950 ret = inputMethodAbility_.SendMessage(arrayBuffer);
951 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
952 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
953
954 InputMethodMessageHandlerTest::ResetParam();
955 ret = inputMethodController_->RegisterMsgHandler(nullptr);
956 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
957 }
958
959 /**
960 * @tc.name: testIMASendMessage_004
961 * @tc.desc: IMA SendMessage, msgId is 0 and msgParam is valid.
962 * @tc.type: FUNC
963 * @tc.require:
964 */
965 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_004, TestSize.Level1)
966 {
967 IMSA_HILOGI("IMA testIMASendMessage_004 Test START");
968 auto messageHandler = std::make_shared<MessageHandlerCallback>();
969 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
970 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
971 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
972 ret = inputMethodController_->Attach(textListener_);
973 std::this_thread::sleep_for(std::chrono::seconds(1));
974 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
975
976 ArrayBuffer arrayBuffer;
977 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
978 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
979 ret = inputMethodAbility_.SendMessage(arrayBuffer);
980 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
981 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
982
983 InputMethodMessageHandlerTest::ResetParam();
984 ret = inputMethodController_->RegisterMsgHandler(nullptr);
985 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
986 }
987
988 /**
989 * @tc.name: testIMASendMessage_005
990 * @tc.desc: IMA SendMessage, msgId is max length and msgParam is valid.
991 * @tc.type: FUNC
992 * @tc.require:
993 */
994 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_005, TestSize.Level1)
995 {
996 IMSA_HILOGI("IMA testIMASendMessage_005 Test START");
997 auto messageHandler = std::make_shared<MessageHandlerCallback>();
998 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
999 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1000 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1001 ret = inputMethodController_->Attach(textListener_);
1002 std::this_thread::sleep_for(std::chrono::seconds(1));
1003 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1004
1005 ArrayBuffer arrayBuffer;
1006 arrayBuffer.msgId = string(MAX_ARRAY_BUFFER_MSG_ID_SIZE, 'a');
1007 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1008 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1009 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1010 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1011 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1012
1013 InputMethodMessageHandlerTest::ResetParam();
1014 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1015 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
1016 }
1017
1018 /**
1019 * @tc.name: testIMASendMessage_006
1020 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is max length.
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
1024 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_006, TestSize.Level1)
1025 {
1026 IMSA_HILOGI("IMA testIMASendMessage_006 Test START");
1027 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1028 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1029 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1030 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1031 ret = inputMethodController_->Attach(textListener_);
1032 std::this_thread::sleep_for(std::chrono::seconds(1));
1033 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1034
1035 ArrayBuffer arrayBuffer;
1036 arrayBuffer.msgId = "testMsgId";
1037 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE, 'a');
1038 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1039 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1040 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1041
1042 InputMethodMessageHandlerTest::ResetParam();
1043 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1044 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, true));
1045 }
1046
1047 /**
1048 * @tc.name: testIMASendMessage_007
1049 * @tc.desc: IMA SendMessage, msgId is valid and msgParam is exceeds max length.
1050 * @tc.type: FUNC
1051 * @tc.require:
1052 */
1053 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_007, TestSize.Level1)
1054 {
1055 IMSA_HILOGI("IMA testIMASendMessage_007 Test START");
1056 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1057 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1058 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1059 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1060 ret = inputMethodController_->Attach(textListener_);
1061 std::this_thread::sleep_for(std::chrono::seconds(1));
1062 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1063
1064 ArrayBuffer arrayBuffer;
1065 arrayBuffer.msgId = "testMsgId";
1066 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1067 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1068 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1069
1070 InputMethodMessageHandlerTest::ResetParam();
1071 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1072 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1073 }
1074
1075 /**
1076 * @tc.name: testIMASendMessage_008
1077 * @tc.desc: IMA SendMessage, msgId is exceeds max length and msgParam is valid.
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_008, TestSize.Level1)
1082 {
1083 IMSA_HILOGI("IMA testIMASendMessage_008 Test START");
1084 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1085 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1086 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1087 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1088 ret = inputMethodController_->Attach(textListener_);
1089 std::this_thread::sleep_for(std::chrono::seconds(1));
1090 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1091
1092 ArrayBuffer arrayBuffer;
1093 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1094 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1095 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1096 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1097 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1098
1099 InputMethodMessageHandlerTest::ResetParam();
1100 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1101 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1102 }
1103
1104 /**
1105 * @tc.name: testIMASendMessage_009
1106 * @tc.desc: IMA SendMessage, msgId and msgParam are all exceed max length.
1107 * @tc.type: FUNC
1108 * @tc.require:
1109 */
1110 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_009, TestSize.Level1)
1111 {
1112 IMSA_HILOGI("IMA testIMASendMessage_009 Test START");
1113 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1114 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1115 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1116 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1117 ret = inputMethodController_->Attach(textListener_);
1118 std::this_thread::sleep_for(std::chrono::seconds(1));
1119 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1120
1121 ArrayBuffer arrayBuffer;
1122 arrayBuffer.msgId = std::string(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1123 arrayBuffer.msgParam.assign(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1124 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1125 EXPECT_EQ(ret, ErrorCode::ERROR_INVALID_ARRAY_BUFFER_SIZE);
1126 InputMethodMessageHandlerTest::ResetParam();
1127 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1128 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1129 }
1130
1131 /**
1132 * @tc.name: testIMASendMessage_010
1133 * @tc.desc: IMA SendMessage, without Attach.
1134 * @tc.type: FUNC
1135 * @tc.require:
1136 */
1137 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_010, TestSize.Level1)
1138 {
1139 IMSA_HILOGI("IMA testIMASendMessage_010 Test START");
1140 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1141 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1142 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1143 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1144
1145 ArrayBuffer arrayBuffer;
1146 arrayBuffer.msgId = "testMsgId";
1147 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1148 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1149 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1150 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
1151
1152 InputMethodMessageHandlerTest::ResetParam();
1153 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1154 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1155 }
1156
1157 /**
1158 * @tc.name: testIMASendMessage_011
1159 * @tc.desc: IMA SendMessage, Attach but not editable.
1160 * @tc.type: FUNC
1161 * @tc.require:
1162 */
1163 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_011, TestSize.Level1)
1164 {
1165 IMSA_HILOGI("IMA testIMASendMessage_011 Test START");
1166 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1167 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1168 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1169 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1170 ret = inputMethodController_->Attach(textListener_);
1171 std::this_thread::sleep_for(std::chrono::seconds(1));
1172 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1173 inputMethodController_->isEditable_.store(false);
1174
1175 ArrayBuffer arrayBuffer;
1176 arrayBuffer.msgId = "testMsgId";
1177 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1178 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1179 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1180 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_EDITABLE);
1181
1182 InputMethodMessageHandlerTest::ResetParam();
1183 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1184 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1185 }
1186
1187 /**
1188 * @tc.name: testIMASendMessage_012
1189 * @tc.desc: IMA SendMessage, another size was not registered message handler.
1190 * @tc.type: FUNC
1191 * @tc.require:
1192 */
1193 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_012, TestSize.Level1)
1194 {
1195 IMSA_HILOGI("IMA testIMASendMessage_012 Test START");
1196 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1197 auto ret = inputMethodController_->Attach(textListener_);
1198 std::this_thread::sleep_for(std::chrono::seconds(1));
1199 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1200
1201 ArrayBuffer arrayBuffer;
1202 arrayBuffer.msgId = "testMsgId";
1203 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1204 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1205 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1206 EXPECT_EQ(ret, ErrorCode::ERROR_MSG_HANDLER_NOT_REGIST);
1207
1208 InputMethodMessageHandlerTest::ResetParam();
1209 }
1210
1211 /**
1212 * @tc.name: testIMASendMessage_013
1213 * @tc.desc: IMA SendMessage, basic security mode.
1214 * @tc.type: FUNC
1215 * @tc.require:
1216 */
1217 HWTEST_F(InputMethodMessageHandlerTest, testIMASendMessage_013, TestSize.Level1)
1218 {
1219 IMSA_HILOGI("IMA testIMASendMessage_013 Test START");
1220 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1221 auto ret = inputMethodController_->RegisterMsgHandler(messageHandler);
1222 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1223 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::BASIC));
1224 ret = inputMethodController_->Attach(textListener_);
1225 std::this_thread::sleep_for(std::chrono::seconds(1));
1226 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1227
1228 ArrayBuffer arrayBuffer;
1229 arrayBuffer.msgId = "testMsgId";
1230 string msgParam = "testParamtestParamtestParamtestParamtestParamtestParam";
1231 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1232 ret = inputMethodAbility_.SendMessage(arrayBuffer);
1233 EXPECT_EQ(ret, ErrorCode::ERROR_SECURITY_MODE_OFF);
1234
1235 InputMethodMessageHandlerTest::ResetParam();
1236 ret = inputMethodController_->RegisterMsgHandler(nullptr);
1237 EXPECT_TRUE(messageHandler->CheckOnTerminatedAndOnMessage(true, false));
1238 }
1239
1240 /**
1241 * @tc.name: testCallbackTiming_001
1242 * @tc.desc: IMC SendMessage, the message handler deliver timing, IMC to IMA.
1243 * @tc.type: FUNC
1244 * @tc.require:
1245 */
1246 HWTEST_F(InputMethodMessageHandlerTest, testCallbackTiming_001, TestSize.Level1)
1247 {
1248 ArrayBuffer arrayBufferA;
1249 arrayBufferA.msgId = "msgIdA";
1250 string msgParamA = "testParamAtestParamAtestParamAtestParamAtestParamA";
1251 arrayBufferA.msgParam.assign(msgParamA.begin(), msgParamA.end());
1252 ArrayBuffer arrayBufferB;
1253 arrayBufferB.msgId = "msgIdB";
1254 string msgParamB = "testParamAtestParamAtestParamAtestParamAtestParamB";
1255 arrayBufferB.msgParam.assign(msgParamB.begin(), msgParamB.end());
1256 ArrayBuffer arrayBufferC;
1257 arrayBufferC.msgId = "msgIdC";
1258 string msgParamC = "testParamAtestParamAtestParamAtestParamAtestParamC";
1259 arrayBufferC.msgParam.assign(msgParamC.begin(), msgParamC.end());
1260
1261 ArrayBuffer arrayBuffer;
1262 arrayBuffer.msgId = arrayBufferA.msgId + arrayBufferB.msgId + arrayBufferC.msgId;
1263 string msgParam = msgParamA + msgParamB + msgParamC;
1264 arrayBuffer.msgParam.assign(msgParam.begin(), msgParam.end());
1265
1266
1267 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1268 auto ret = inputMethodController_->Attach(textListener_);
1269 std::this_thread::sleep_for(std::chrono::seconds(1));
1270 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1271 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1272 ret = inputMethodAbility_.RegisterMsgHandler(messageHandler);
1273 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1274
1275 ret = inputMethodController_->SendMessage(arrayBufferA);
1276 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1277 ret = inputMethodController_->SendMessage(arrayBufferB);
1278 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1279 ret = inputMethodController_->SendMessage(arrayBufferC);
1280 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1281
1282 EXPECT_EQ(MessageHandlerCallback::GetTimingArrayBuffer(), arrayBuffer);
1283 InputMethodMessageHandlerTest::ResetParam();
1284 }
1285
1286 /**
1287 * @tc.name: textMessageHandlerProxy_001
1288 * @tc.desc: create and destroy MessageHandlerProxy success
1289 * @tc.type: FUNC
1290 * @tc.require:
1291 */
1292 HWTEST_F(InputMethodMessageHandlerTest, textMessageHandlerProxy_001, TestSize.Level1)
1293 {
1294 IMSA_HILOGI("Capi textMessageHandlerProxy_001 Test START");
1295 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1296 ASSERT_NE(nullptr, messageHanlderProxy);
1297 InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(messageHanlderProxy);
1298 InputMethodMessageHandlerTest::TestGetMessageHandlerProxyMember(messageHanlderProxy);
1299 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1300 }
1301
1302 /**
1303 * @tc.name: testSendMessageCapi_001
1304 * @tc.desc: input parameters invalid.
1305 * @tc.type: FUNC
1306 * @tc.require:
1307 */
1308 HWTEST_F(InputMethodMessageHandlerTest, testSendMessageCapi_001, TestSize.Level1)
1309 {
1310 IMSA_HILOGI("Capi testSendMessageCapi_001 Test START");
1311 InputMethod_InputMethodProxy *imeProxy = nullptr;
1312 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1313 EXPECT_EQ(ret, IME_ERR_OK);
1314 ASSERT_NE(nullptr, imeProxy);
1315
1316 std::u16string msgIdStr = u"msgId";
1317 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1318 vector<uint8_t> msgParam(msgParamStr.begin(), msgParamStr.end());
1319
1320 std::u16string msgIdStrOverSize(MAX_ARRAY_BUFFER_MSG_ID_SIZE + 1, 'a');
1321 vector<uint8_t> msgParamOverSize(MAX_ARRAY_BUFFER_MSG_PARAM_SIZE + 1, 'a');
1322
1323 ret = OH_InputMethodProxy_SendMessage(nullptr,
1324 msgIdStr.c_str(), msgIdStr.length(), msgParam.data(), msgParam.size());
1325 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1326 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1327 nullptr, msgIdStr.length(), msgParam.data(), msgParam.size());
1328 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1329 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1330 msgIdStr.c_str(), msgIdStr.length(), nullptr, msgParam.size());
1331 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1332
1333 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1334 msgIdStrOverSize.c_str(), msgIdStrOverSize.length(), msgParam.data(), msgParam.size());
1335 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1336 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1337 msgIdStr.c_str(), msgIdStr.length(), msgParamOverSize.data(), msgParamOverSize.size());
1338 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1339 ret = OH_InputMethodProxy_SendMessage(imeProxy,
1340 msgIdStrOverSize.c_str(), msgIdStrOverSize.length(), msgParamOverSize.data(), msgParamOverSize.size());
1341 EXPECT_EQ(ret, IME_ERR_PARAMCHECK);
1342
1343 ret = OH_InputMethodController_Detach(imeProxy);
1344 EXPECT_EQ(ret, IME_ERR_OK);
1345 InputMethodMessageHandlerTest::ResetParam();
1346 }
1347
1348 /**
1349 * @tc.name: testSendMessageCapi_002
1350 * @tc.desc: input valid parameters.
1351 * @tc.type: FUNC
1352 * @tc.require:
1353 */
1354 HWTEST_F(InputMethodMessageHandlerTest, testSendMessageCapi_002, TestSize.Level1)
1355 {
1356 IMSA_HILOGI("Capi testSendMessageCapi_002 Test START");
1357 InputMethod_InputMethodProxy *imeProxy = nullptr;
1358 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1359 EXPECT_EQ(ret, IME_ERR_OK);
1360 ASSERT_NE(nullptr, imeProxy);
1361 std::this_thread::sleep_for(std::chrono::seconds(1));
1362 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1363 auto messageHandler = std::make_shared<MessageHandlerCallback>();
1364 auto res = inputMethodAbility_.RegisterMsgHandler(messageHandler);
1365 EXPECT_EQ(res, ErrorCode::NO_ERROR);
1366
1367 ArrayBuffer arrayBuffer;
1368 arrayBuffer.msgId = "msgId";
1369 std::u16string msgIdStr = Str8ToStr16(arrayBuffer.msgId);
1370 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1371 arrayBuffer.msgParam.assign(msgParamStr.begin(), msgParamStr.end());
1372
1373 ret = OH_InputMethodProxy_SendMessage(
1374 imeProxy, msgIdStr.c_str(), msgIdStr.length(), arrayBuffer.msgParam.data(), msgParamStr.size());
1375 EXPECT_EQ(ret, IME_ERR_OK);
1376
1377 EXPECT_TRUE(MessageHandlerCallback::WaitSendMessage(arrayBuffer));
1378 ret = OH_InputMethodController_Detach(imeProxy);
1379 EXPECT_EQ(ret, IME_ERR_OK);
1380 InputMethodMessageHandlerTest::ResetParam();
1381 res = inputMethodAbility_.RegisterMsgHandler();
1382 EXPECT_EQ(res, ErrorCode::NO_ERROR);
1383 }
1384
1385 /**
1386 * @tc.name: testRecvMessageCapi_001
1387 * @tc.desc: register inputmethod message handler with invalid param.
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_001, TestSize.Level1)
1392 {
1393 IMSA_HILOGI("Capi testRecvMessageCapi_001 Test START");
1394 InputMethod_InputMethodProxy *imeProxy = nullptr;
1395 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1396 EXPECT_EQ(ret, IME_ERR_OK);
1397 ASSERT_NE(nullptr, imeProxy);
1398
1399 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1400 ASSERT_NE(nullptr, messageHanlderProxy);
1401 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy);
1402 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1403
1404 InputMethodMessageHandlerTest::ConstructMessageHandlerProxy(messageHanlderProxy);
1405 ret = OH_InputMethodProxy_RecvMessage(nullptr, messageHanlderProxy);
1406 EXPECT_EQ(ret, IME_ERR_NULL_POINTER);
1407
1408 ret = OH_InputMethodController_Detach(imeProxy);
1409 EXPECT_EQ(ret, IME_ERR_OK);
1410 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1411 InputMethodMessageHandlerTest::ResetParam();
1412 }
1413
1414 /**
1415 * @tc.name: testRecvMessageCapi_002
1416 * @tc.desc: register inputmethod message handler with valid param.
1417 * @tc.type: FUNC
1418 * @tc.require:
1419 */
1420 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_002, TestSize.Level1)
1421 {
1422 IMSA_HILOGI("Capi testRecvMessageCapi_002 Test START");
1423 InputMethod_InputMethodProxy *imeProxy = nullptr;
1424 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1425 EXPECT_EQ(ret, IME_ERR_OK);
1426 ASSERT_NE(nullptr, imeProxy);
1427
1428 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1429 EXPECT_EQ(ret, IME_ERR_OK);
1430
1431 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1432 EXPECT_EQ(ret, IME_ERR_OK);
1433 ret = OH_InputMethodController_Detach(imeProxy);
1434 EXPECT_EQ(ret, IME_ERR_OK);
1435 InputMethodMessageHandlerTest::ResetParam();
1436 }
1437
1438 /**
1439 * @tc.name: testRecvMessageCapi_003
1440 * @tc.desc: register another inputmethod message handler, will triiger exMessage handler OnTerminated.
1441 * @tc.type: FUNC
1442 * @tc.require:
1443 */
1444 HWTEST_F(InputMethodMessageHandlerTest, testRecvMessageCapi_003, TestSize.Level1)
1445 {
1446 IMSA_HILOGI("Capi testRecvMessageCapi_003 Test START");
1447 InputMethod_InputMethodProxy *imeProxy = nullptr;
1448 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1449 EXPECT_EQ(ret, IME_ERR_OK);
1450 ASSERT_NE(nullptr, imeProxy);
1451
1452 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1453 EXPECT_EQ(ret, IME_ERR_OK);
1454 auto messageHanlderProxy = OH_MessageHandlerProxy_Create();
1455 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnTerminatedFunc(messageHanlderProxy, OnTerminatedFuncNew));
1456 EXPECT_EQ(IME_ERR_OK, OH_MessageHandlerProxy_SetOnMessageFunc(messageHanlderProxy, OnMessageFunc));
1457 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy);
1458 EXPECT_EQ(ret, IME_ERR_OK);
1459 EXPECT_TRUE(g_onTerminated);
1460 EXPECT_FALSE(g_onMessage);
1461 EXPECT_FALSE(g_onTerminatedNew);
1462
1463 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1464 EXPECT_EQ(ret, IME_ERR_OK);
1465 OH_MessageHandlerProxy_Destroy(messageHanlderProxy);
1466 ret = OH_InputMethodController_Detach(imeProxy);
1467 EXPECT_EQ(ret, IME_ERR_OK);
1468 InputMethodMessageHandlerTest::ResetParam();
1469 }
1470
1471 /**
1472 * @tc.name: testMessageHandelrCallbackCapi_001
1473 * @tc.desc: recv message handler from ima.
1474 * @tc.type: FUNC
1475 * @tc.require:
1476 */
1477 HWTEST_F(InputMethodMessageHandlerTest, testMessageHandelrCallbackCapi_001, TestSize.Level1)
1478 {
1479 IMSA_HILOGI("Capi testMessageHandelrCallbackCapi_001 Test START");
1480 InputMethod_InputMethodProxy *imeProxy = nullptr;
1481 auto ret = OH_InputMethodController_Attach(textEditorProxy_, option_, &imeProxy);
1482 EXPECT_EQ(ret, IME_ERR_OK);
1483 ASSERT_NE(nullptr, imeProxy);
1484 ret = OH_InputMethodProxy_RecvMessage(imeProxy, messageHanlderProxy_);
1485 EXPECT_EQ(ret, IME_ERR_OK);
1486 std::this_thread::sleep_for(std::chrono::seconds(1));
1487 InputMethodMessageHandlerTest::SetSecurityModeEnable(static_cast<int32_t>(SecurityMode::FULL));
1488
1489 ArrayBuffer arrayBuffer;
1490 arrayBuffer.msgId = "msgId";
1491 std::u16string msgIdStr = Str8ToStr16(arrayBuffer.msgId);
1492 string msgParamStr = "testParamtestParamtestParamtestParamtestParamtestParam";
1493 arrayBuffer.msgParam.assign(msgParamStr.begin(), msgParamStr.end());
1494 EXPECT_EQ(inputMethodAbility_.SendMessage(arrayBuffer), ErrorCode::NO_ERROR);
1495 EXPECT_TRUE(WaitOnMessageFunc(arrayBuffer));
1496
1497 ret = OH_InputMethodProxy_RecvMessage(imeProxy, nullptr);
1498 EXPECT_EQ(ret, IME_ERR_OK);
1499 ret = OH_InputMethodController_Detach(imeProxy);
1500 EXPECT_EQ(ret, IME_ERR_OK);
1501 InputMethodMessageHandlerTest::ResetParam();
1502 }
1503 } // namespace MiscServices
1504 } // namespace OHOS