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 #undef private
23
24 #include <event_handler.h>
25 #include <gtest/gtest.h>
26 #include <string_ex.h>
27
28 #include <condition_variable>
29 #include <csignal>
30 #include <cstdint>
31 #include <mutex>
32 #include <string>
33 #include <vector>
34
35 #include "global.h"
36 #include "i_input_method_agent.h"
37 #include "i_input_method_system_ability.h"
38 #include "identity_checker_mock.h"
39 #include "inputmethod_controller_capi.h"
40 #include "inputmethod_message_handler_proxy_capi.h"
41 #include "input_client_stub.h"
42 #include "input_death_recipient.h"
43 #include "input_method_ability.h"
44 #include "input_method_engine_listener_impl.h"
45 #include "input_method_system_ability_proxy.h"
46 #include "input_method_utils.h"
47 #include "keyboard_listener.h"
48 #include "message_parcel.h"
49 #include "string_ex.h"
50 #include "tdd_util.h"
51 #include "text_listener.h"
52 #include "msg_handler_callback_interface.h"
53
54 using namespace testing;
55 using namespace testing::ext;
56 namespace OHOS {
57 namespace MiscServices {
58 ArrayBuffer g_arrayBufferCapi;
59 std::mutex g_messageHandlerMutex;
60 std::condition_variable g_messageHandlerCv;
61 bool g_onTerminated = false;
62 bool g_onMessage = false;
63 bool g_onTerminatedNew = false;
OnMessageFunc(InputMethod_MessageHandlerProxy * proxy,const char16_t msgId[],size_t msgIdLength,const uint8_t * msgParam,size_t msgParamLength)64 int32_t OnMessageFunc(InputMethod_MessageHandlerProxy *proxy,
65 const char16_t msgId[], size_t msgIdLength, const uint8_t *msgParam, size_t msgParamLength)
66 {
67 std::unique_lock<std::mutex> lock(g_messageHandlerMutex);
68 std::u16string msgIdStr(msgId, msgIdLength);
69 g_arrayBufferCapi.msgId = Str16ToStr8(msgIdStr);
70 g_arrayBufferCapi.msgParam.assign(msgParam, msgParam + msgParamLength);
71 g_onMessage = true;
72 g_messageHandlerCv.notify_one();
73 return 0;
74 }
75
WaitOnMessageFunc(const ArrayBuffer & arrayBuffer)76 bool WaitOnMessageFunc(const ArrayBuffer &arrayBuffer)
77 {
78 std::unique_lock<std::mutex> lock(g_messageHandlerMutex);
79 g_messageHandlerCv.wait_for(lock, std::chrono::seconds(1), [&arrayBuffer]() {
80 return g_arrayBufferCapi == arrayBuffer;
81 });
82 return g_arrayBufferCapi == arrayBuffer;
83 }
OnTerminatedFunc(InputMethod_MessageHandlerProxy * proxy)84 int32_t OnTerminatedFunc(InputMethod_MessageHandlerProxy *proxy)
85 {
86 g_onTerminated = true;
87 return 0;
88 }
89
OnTerminatedFuncNew(InputMethod_MessageHandlerProxy * proxy)90 int32_t OnTerminatedFuncNew(InputMethod_MessageHandlerProxy *proxy)
91 {
92 g_onTerminatedNew = true;
93 return 0;
94 }
GetTextConfigFunc(InputMethod_TextEditorProxy * proxy,InputMethod_TextConfig * config)95 void GetTextConfigFunc(InputMethod_TextEditorProxy *proxy, InputMethod_TextConfig *config) { }
InsertTextFunc(InputMethod_TextEditorProxy * proxy,const char16_t * text,size_t length)96 void InsertTextFunc(InputMethod_TextEditorProxy *proxy, const char16_t *text, size_t length) { }
DeleteForwardFunc(InputMethod_TextEditorProxy * proxy,int32_t length)97 void DeleteForwardFunc(InputMethod_TextEditorProxy *proxy, int32_t length) { }
DeleteBackwardFunc(InputMethod_TextEditorProxy * proxy,int32_t length)98 void DeleteBackwardFunc(InputMethod_TextEditorProxy *proxy, int32_t length) { }
SendKeyboardStatusFunc(InputMethod_TextEditorProxy * proxy,InputMethod_KeyboardStatus status)99 void SendKeyboardStatusFunc(InputMethod_TextEditorProxy *proxy, InputMethod_KeyboardStatus status) { }
SendEnterKeyFunc(InputMethod_TextEditorProxy * proxy,InputMethod_EnterKeyType type)100 void SendEnterKeyFunc(InputMethod_TextEditorProxy *proxy, InputMethod_EnterKeyType type) { }
MoveCursorFunc(InputMethod_TextEditorProxy * proxy,InputMethod_Direction direction)101 void MoveCursorFunc(InputMethod_TextEditorProxy *proxy, InputMethod_Direction direction) { }
HandleSetSelectionFunc(InputMethod_TextEditorProxy * proxy,int32_t start,int32_t end)102 void HandleSetSelectionFunc(InputMethod_TextEditorProxy *proxy, int32_t start, int32_t end) { }
HandleExtendActionFunc(InputMethod_TextEditorProxy * proxy,InputMethod_ExtendAction action)103 void HandleExtendActionFunc(InputMethod_TextEditorProxy *proxy, InputMethod_ExtendAction action) { }
GetleftTextOfCursorFunc(InputMethod_TextEditorProxy * proxy,int32_t number,char16_t text[],size_t * length)104 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)105 void GetRightTextOfCursorFunc(InputMethod_TextEditorProxy *proxy, int32_t number, char16_t text[], size_t *length) { }
GetTextIndexAtCursorFunc(InputMethod_TextEditorProxy * proxy)106 int32_t GetTextIndexAtCursorFunc(InputMethod_TextEditorProxy *proxy)
107 {
108 return 0;
109 }
ReceivePrivateCommandFunc(InputMethod_TextEditorProxy * proxy,InputMethod_PrivateCommand * privateCommand[],size_t size)110 int32_t ReceivePrivateCommandFunc(
111 InputMethod_TextEditorProxy *proxy, InputMethod_PrivateCommand *privateCommand[], size_t size)
112 {
113 return 0;
114 }
SetPreviewTextFunc(InputMethod_TextEditorProxy * proxy,const char16_t * text,size_t length,int32_t start,int32_t end)115 int32_t SetPreviewTextFunc(
116 InputMethod_TextEditorProxy *proxy, const char16_t *text, size_t length, int32_t start, int32_t end)
117 {
118 return 0;
119 }
FinishTextPreviewFunc(InputMethod_TextEditorProxy * proxy)120 void FinishTextPreviewFunc(InputMethod_TextEditorProxy *proxy) { }
121 class MessageHandlerCallback : public MsgHandlerCallbackInterface {
122 public:
123 using onTerminatedFunc = std::function<void()>;
124 using onMessageFunc = std::function<void(const ArrayBuffer &arrayBuffer)>;
MessageHandlerCallback()125 MessageHandlerCallback() {};
~MessageHandlerCallback()126 virtual ~MessageHandlerCallback() {};
127 int32_t OnTerminated() override;
128 int32_t OnMessage(const ArrayBuffer &arrayBuffer) override;
129 void SetOnTernimateFunc(onTerminatedFunc func);
130 void SetOnMessageFunc(onMessageFunc func);
131 bool CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute, bool isOnMessageExcute);
132 static void OnMessageCallback(const ArrayBuffer &arrayBuffer);
133 static bool WaitSendMessage(const ArrayBuffer &arrayBuffer);
134 static void ClearArrayBuffer();
135 static ArrayBuffer GetTimingArrayBuffer();
136 void ClearParam();
137 private:
138 onTerminatedFunc onTerminatedFunc_ = nullptr;
139 onMessageFunc onMessageFunc_ = nullptr;
140 bool isTriggerOnTerminated_ = false;
141 bool isTriggerOnMessage_ = false;
142 static std::mutex messageHandlerMutex_;
143 static std::condition_variable messageHandlerCv_;
144 static ArrayBuffer arrayBuffer_;
145 static ArrayBuffer timingArrayBuffer_;
146 };
147 std::mutex MessageHandlerCallback::messageHandlerMutex_;
148 std::condition_variable MessageHandlerCallback::messageHandlerCv_;
149 ArrayBuffer MessageHandlerCallback::arrayBuffer_;
150 ArrayBuffer MessageHandlerCallback::timingArrayBuffer_;
151
OnTerminated()152 int32_t MessageHandlerCallback::OnTerminated()
153 {
154 isTriggerOnTerminated_ = true;
155 if (onTerminatedFunc_ != nullptr) {
156 onTerminatedFunc_();
157 }
158 return ErrorCode::NO_ERROR;
159 }
160
OnMessage(const ArrayBuffer & arrayBuffer)161 int32_t MessageHandlerCallback::OnMessage(const ArrayBuffer &arrayBuffer)
162 {
163 std::string msgParam(arrayBuffer_.msgParam.begin(), arrayBuffer_.msgParam.end());
164 std::string msgParam1(arrayBuffer.msgParam.begin(), arrayBuffer.msgParam.end());
165 IMSA_HILOGE("arrayBuffer_ msgId: %{public}s, msgParam: %{publid}s",
166 arrayBuffer_.msgId.c_str(), msgParam.c_str());
167 IMSA_HILOGE("arrayBuffer msgId: %{public}s, msgParam: %{publid}s",
168 arrayBuffer.msgId.c_str(), msgParam1.c_str());
169 isTriggerOnMessage_ = true;
170 if (onMessageFunc_ != nullptr) {
171 onMessageFunc_(arrayBuffer);
172 }
173 OnMessageCallback(arrayBuffer);
174 timingArrayBuffer_.msgId += arrayBuffer.msgId;
175 timingArrayBuffer_.msgParam.insert(
176 timingArrayBuffer_.msgParam.end(), arrayBuffer.msgParam.begin(), arrayBuffer.msgParam.end());
177 return ErrorCode::NO_ERROR;
178 }
179
SetOnTernimateFunc(onTerminatedFunc func)180 void MessageHandlerCallback::SetOnTernimateFunc(onTerminatedFunc func)
181 {
182 onTerminatedFunc_ = func;
183 }
184
SetOnMessageFunc(onMessageFunc func)185 void MessageHandlerCallback::SetOnMessageFunc(onMessageFunc func)
186 {
187 onMessageFunc_ = func;
188 }
189
CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute,bool isOnMessageExcute)190 bool MessageHandlerCallback::CheckOnTerminatedAndOnMessage(bool isOnTerminatedExcute, bool isOnMessageExcute)
191 {
192 return isOnTerminatedExcute == isTriggerOnTerminated_ && isOnMessageExcute == isTriggerOnMessage_;
193 }
194
OnMessageCallback(const ArrayBuffer & arrayBuffer)195 void MessageHandlerCallback::OnMessageCallback(const ArrayBuffer &arrayBuffer)
196 {
197 IMSA_HILOGI("OnMessageCallback");
198 std::unique_lock<std::mutex> lock(messageHandlerMutex_);
199 arrayBuffer_ = arrayBuffer;
200 messageHandlerCv_.notify_one();
201 }
202
WaitSendMessage(const ArrayBuffer & arrayBuffer)203 bool MessageHandlerCallback::WaitSendMessage(const ArrayBuffer &arrayBuffer)
204 {
205 std::unique_lock<std::mutex> lock(messageHandlerMutex_);
206 messageHandlerCv_.wait_for(lock, std::chrono::seconds(1), [&arrayBuffer]() {
207 return arrayBuffer_ == arrayBuffer;
208 });
209 return arrayBuffer_ == arrayBuffer;
210 }
211
ClearArrayBuffer()212 void MessageHandlerCallback::ClearArrayBuffer()
213 {
214 arrayBuffer_.msgId.clear();
215 arrayBuffer_.msgParam.clear();
216 g_arrayBufferCapi.msgId.clear();
217 g_arrayBufferCapi.msgParam.clear();
218 timingArrayBuffer_.msgId.clear();
219 timingArrayBuffer_.msgParam.clear();
220 }
221
GetTimingArrayBuffer()222 ArrayBuffer MessageHandlerCallback::GetTimingArrayBuffer()
223 {
224 return timingArrayBuffer_;
225 }
226
ClearParam()227 void MessageHandlerCallback::ClearParam()
228 {
229 isTriggerOnTerminated_ = false;
230 isTriggerOnMessage_ = false;
231 }
232
233 class InputMethodMessageHandlerTest : public testing::Test {
234 public:
235 static void SetUpTestCase(void);
236 static void TearDownTestCase(void);
237 void SetUp();
238 void TearDown();
239 static void SetSecurityModeEnable(int32_t securityMode);
240 static void ResetParam();
241 static void ConstructMessageHandlerProxy(InputMethod_MessageHandlerProxy *messageHandlerProxy);
242 static void TestGetMessageHandlerProxyMember(InputMethod_MessageHandlerProxy *messageHandlerProxy);
243 static void ConstructTextEditorProxy(InputMethod_TextEditorProxy *textEditorProxy);
244 static sptr<InputMethodController> inputMethodController_;
245 static sptr<InputMethodAbility> inputMethodAbility_;
246 static sptr<InputMethodSystemAbility> imsa_;
247 static sptr<InputMethodSystemAbilityProxy> imsaProxy_;
248 static std::shared_ptr<InputMethodEngineListenerImpl> imeListener_;
249 static sptr<OnTextChangedListener> textListener_;
250 static InputMethod_AttachOptions *option_;
251 static InputMethod_TextEditorProxy *textEditorProxy_;
252 static InputMethod_MessageHandlerProxy *messageHanlderProxy_;
253 };
254 sptr<InputMethodController> InputMethodMessageHandlerTest::inputMethodController_;
255 sptr<InputMethodAbility> InputMethodMessageHandlerTest::inputMethodAbility_;
256 sptr<InputMethodSystemAbility> InputMethodMessageHandlerTest::imsa_;
257 sptr<InputMethodSystemAbilityProxy> InputMethodMessageHandlerTest::imsaProxy_;
258 std::shared_ptr<InputMethodEngineListenerImpl> InputMethodMessageHandlerTest::imeListener_;
259 sptr<OnTextChangedListener> InputMethodMessageHandlerTest::textListener_;
260 InputMethod_AttachOptions *InputMethodMessageHandlerTest::option_ = nullptr;
261 InputMethod_TextEditorProxy *InputMethodMessageHandlerTest::textEditorProxy_ = nullptr;
262 InputMethod_MessageHandlerProxy *InputMethodMessageHandlerTest::messageHanlderProxy_ = nullptr;
263
SetUpTestCase(void)264 void InputMethodMessageHandlerTest::SetUpTestCase(void)
265 {
266 IMSA_HILOGI("InputMethodMessageHandlerTest::SetUpTestCase");
267 IdentityCheckerMock::ResetParam();
268 imsa_ = new (std::nothrow) InputMethodSystemAbility();
269 if (imsa_ == nullptr) {
270 return;
271 }
272 imsa_->OnStart();
273 imsa_->userId_ = TddUtil::GetCurrentUserId();
274 imsa_->identityChecker_ = std::make_shared<IdentityCheckerMock>();
275 sptr<InputMethodSystemAbilityStub> serviceStub = imsa_;
276 imsaProxy_ = new (std::nothrow) InputMethodSystemAbilityProxy(serviceStub->AsObject());
277 if (imsaProxy_ == nullptr) {
278 return;
279 }
280 IdentityCheckerMock::SetFocused(true);
281
282 inputMethodAbility_ = InputMethodAbility::GetInstance();
283 inputMethodAbility_->abilityManager_ = imsaProxy_;
284 textListener_ = new TextListener();
285 TddUtil::InitCurrentImePermissionInfo();
286 IdentityCheckerMock::SetBundleName(TddUtil::currentBundleNameMock_);
287 inputMethodAbility_->SetCoreAndAgent();
288 imeListener_ = std::make_shared<InputMethodEngineListenerImpl>();
289 inputMethodAbility_->SetImeListener(imeListener_);
290
291 inputMethodController_ = InputMethodController::GetInstance();
292 inputMethodController_->abilityManager_ = imsaProxy_;
293
294 option_ = OH_AttachOptions_Create(true);
295 textEditorProxy_ = OH_TextEditorProxy_Create();
296 ConstructTextEditorProxy(textEditorProxy_);
297 messageHanlderProxy_ = OH_MessageHandlerProxy_Create();
298 ConstructMessageHandlerProxy(messageHanlderProxy_);
299 }
300
TearDownTestCase(void)301 void InputMethodMessageHandlerTest::TearDownTestCase(void)
302 {
303 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDownTestCase");
304 inputMethodController_->SetControllerListener(nullptr);
305 IdentityCheckerMock::ResetParam();
306 imsa_->OnStop();
307 OH_AttachOptions_Destroy(option_);
308 OH_TextEditorProxy_Destroy(textEditorProxy_);
309 OH_MessageHandlerProxy_Destroy(messageHanlderProxy_);
310 }
311
SetUp(void)312 void InputMethodMessageHandlerTest::SetUp(void)
313 {
314 IMSA_HILOGI("InputMethodMessageHandlerTest::SetUp");
315 }
316
TearDown(void)317 void InputMethodMessageHandlerTest::TearDown(void)
318 {
319 IMSA_HILOGI("InputMethodMessageHandlerTest::TearDown");
320 std::this_thread::sleep_for(std::chrono::seconds(1));
321 ResetParam();
322 }
323
SetSecurityModeEnable(int32_t securityMode)324 void InputMethodMessageHandlerTest::SetSecurityModeEnable(int32_t securityMode)
325 {
326 if (inputMethodAbility_ != nullptr) {
327 inputMethodAbility_->securityMode_.store(securityMode);
328 }
329 }
330
ResetParam()331 void InputMethodMessageHandlerTest::ResetParam()
332 {
333 inputMethodController_->Close();
334 if (inputMethodAbility_ != nullptr) {
335 inputMethodAbility_->securityMode_.store(-1);
336 }
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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_NE(ret, ErrorCode::NO_ERROR);
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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