1 /*
2 * Copyright (c) 2021-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 #include <gtest/gtest.h>
16 #include <functional>
17
18 #include "ans_inner_errors.h"
19 #include "ans_manager_proxy.h"
20 #include "notification_local_live_view_content.h"
21 #include "notification_local_live_view_subscriber.h"
22 #define private public
23 #include "advanced_notification_service.h"
24 #undef private
25 #include "datetime_ex.h"
26 #include "if_system_ability_manager.h"
27 #include "int_wrapper.h"
28 #include "iservice_registry.h"
29 #include "notification_helper.h"
30 #include "notification_json_convert.h"
31 #include "remote_native_token.h"
32 #include "system_ability_definition.h"
33 #include "want_agent_info.h"
34 #include "want_agent_helper.h"
35 #include "want_params.h"
36 #include "accesstoken_kit.h"
37
38 using namespace testing::ext;
39 using namespace OHOS::Security::AccessToken;
40 namespace OHOS {
41 namespace Notification {
42 extern void MockGetTokenTypeFlag(ATokenTypeEnum mockRet);
43
44 static sptr<ISystemAbilityManager> systemAbilityManager =
45 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
46 bool g_onConsumedReceived = false;
47 bool g_onCanceledReceived = false;
48 bool g_onWantReceived = false;
49 bool g_onBadgeNumberReceived = false;
50 const int32_t SLEEP_TIME = 1;
51 const uint64_t ACTIVE_NUMS = 2;
52 const int32_t CASE_ONE = 1;
53 const int32_t CASE_TWO = 2;
54 const int32_t CASE_THREE = 3;
55 const int32_t CASE_FOUR = 4;
56 const int32_t CASE_FIVE = 5;
57 const int32_t CASE_SIX = 6;
58 const int32_t CASE_SEVEN = 7;
59 const int32_t CASE_EIGHT = 8;
60 const int32_t CASE_NINE = 9;
61 const int32_t CASE_TEN = 10;
62 const int32_t CASE_ELEVEN = 11;
63 const int32_t CASE_TWELVE = 12;
64 const int32_t CASE_THIRTEEN = 13;
65 const int32_t CASE_FOURTEEN = 14;
66 const int32_t CASE_FIFTEEN = 15;
67 const int32_t CASE_SIXTEEN = 16;
68 const int32_t CASE_SEVENTEEN = 17;
69 const int32_t CASE_EIGHTEEN = 18;
70 const int32_t CASE_NINETEEN = 19;
71 const int32_t CASE_TWENTY = 20;
72 const int32_t CASE_TWENTY_ONE = 21;
73
74 const int32_t PIXEL_MAP_TEST_WIDTH = 32;
75 const int32_t PIXEL_MAP_TEST_HEIGHT = 32;
76
77 const int32_t CANCELGROUP_NID = 10101;
78 const int32_t BADGE_NUMBER = 100;
79
80 std::mutex g_subscribe_mtx;
81 std::mutex g_consumed_mtx;
82 std::mutex g_unsubscribe_mtx;
83 std::mutex g_send_finished_mtx;
84 AAFwk::Want g_want;
85
86 std::mutex g_system_live_view_subscribe_mtx;
87 std::mutex g_system_live_view_subscribe_response_mtx;
88 std::string g_onResponseReceivedButtonName {"testButton"};
89 int32_t g_onResponseReceivedId = -1;
90
91 const time_t TIME_OUT_SECONDS_LIMIT = 5;
92 const std::string CLASSIFICATION_ALARM {"alarm"};
93
94 class TestLocalLiveViewSubscriber : public NotificationLocalLiveViewSubscriber {
OnConnected()95 void OnConnected()
96 {}
97
OnDisconnected()98 void OnDisconnected()
99 {}
100
OnResponse(int32_t notificationId,sptr<NotificationButtonOption> buttonOption)101 void OnResponse(int32_t notificationId, sptr<NotificationButtonOption> buttonOption)
102 {
103 GTEST_LOG_(INFO) << "OnResponse notificationId : " << notificationId;
104 g_onResponseReceivedId = notificationId;
105 g_onResponseReceivedButtonName = buttonOption->GetButtonName();
106 g_system_live_view_subscribe_response_mtx.unlock();
107 }
108
OnDied()109 void OnDied()
110 {}
111 };
112
113 class TestAnsSubscriber : public NotificationSubscriber {
114 public:
OnConnected()115 void OnConnected() override
116 {
117 g_subscribe_mtx.unlock();
118 }
119
OnDisconnected()120 void OnDisconnected() override
121 {
122 g_unsubscribe_mtx.unlock();
123 }
124
OnDied()125 void OnDied() override
126 {}
127
OnEnabledNotificationChanged(const std::shared_ptr<EnabledNotificationCallbackData> & callbackData)128 void OnEnabledNotificationChanged(
129 const std::shared_ptr<EnabledNotificationCallbackData> &callbackData) override
130 {}
131
OnDoNotDisturbDateChange(const std::shared_ptr<NotificationDoNotDisturbDate> & date)132 void OnDoNotDisturbDateChange(const std::shared_ptr<NotificationDoNotDisturbDate> &date) override
133 {}
134
OnUpdate(const std::shared_ptr<NotificationSortingMap> & sortingMap)135 void OnUpdate(const std::shared_ptr<NotificationSortingMap> &sortingMap) override
136 {}
137
OnCanceled(const std::shared_ptr<Notification> & request,const std::shared_ptr<NotificationSortingMap> & sortingMap,int deleteReason)138 void OnCanceled(const std::shared_ptr<Notification> &request,
139 const std::shared_ptr<NotificationSortingMap> &sortingMap, int deleteReason) override
140 {
141 g_onCanceledReceived = true;
142 }
143
OnConsumed(const std::shared_ptr<Notification> & request,const std::shared_ptr<NotificationSortingMap> & sortingMap)144 void OnConsumed(const std::shared_ptr<Notification> &request,
145 const std::shared_ptr<NotificationSortingMap> &sortingMap) override
146 {
147 g_onConsumedReceived = true;
148 g_consumed_mtx.unlock();
149 NotificationRequest notificationRequest = request->GetNotificationRequest();
150 GTEST_LOG_(INFO) << "OnConsumed notificationId : " << notificationRequest.GetNotificationId();
151 if (CASE_ONE == notificationRequest.GetNotificationId()) {
152 CheckCaseOneResult(notificationRequest);
153 } else if (CASE_TWO == notificationRequest.GetNotificationId()) {
154 CheckCaseTwoResult(notificationRequest);
155 } else if (CASE_THREE == notificationRequest.GetNotificationId()) {
156 CheckCaseThreeResult(notificationRequest);
157 } else if (CASE_FOUR == notificationRequest.GetNotificationId()) {
158 CheckCaseFourResult(notificationRequest);
159 } else if (CASE_FIVE == notificationRequest.GetNotificationId()) {
160 CheckCaseFiveResult(notificationRequest);
161 } else if (CASE_SIX == notificationRequest.GetNotificationId()) {
162 CheckCaseSixResult(notificationRequest);
163 } else if (CASE_SEVEN == notificationRequest.GetNotificationId()) {
164 CheckCaseSevenResult(notificationRequest);
165 } else if (CASE_EIGHT == notificationRequest.GetNotificationId()) {
166 CheckCaseEightResult(notificationRequest);
167 } else if (CASE_NINE == notificationRequest.GetNotificationId()) {
168 CheckCaseNineResult(notificationRequest);
169 } else if (CASE_TEN == notificationRequest.GetNotificationId()) {
170 EXPECT_EQ(NotificationConstant::SERVICE_REMINDER, notificationRequest.GetSlotType());
171 } else if (CASE_ELEVEN == notificationRequest.GetNotificationId()) {
172 EXPECT_EQ(NotificationConstant::SOCIAL_COMMUNICATION, notificationRequest.GetSlotType());
173 } else if (CASE_TWELVE == notificationRequest.GetNotificationId()) {
174 EXPECT_EQ(NotificationConstant::CUSTOM, notificationRequest.GetSlotType());
175 } else if (CASE_THIRTEEN == notificationRequest.GetNotificationId()) {
176 EXPECT_EQ(NotificationRequest::GroupAlertType::ALL, notificationRequest.GetGroupAlertType());
177 EXPECT_EQ(true, notificationRequest.IsGroupOverview());
178 } else if (CASE_FOURTEEN == notificationRequest.GetNotificationId()) {
179 CheckCaseFourteenResult(notificationRequest);
180 } else if (CASE_FIFTEEN == notificationRequest.GetNotificationId()) {
181 CheckCaseFifteenResult(notificationRequest);
182 } else if (CASE_SIXTEEN == notificationRequest.GetNotificationId()) {
183 CheckCaseSixteenResult(notificationRequest);
184 } else if (CASE_SEVENTEEN == notificationRequest.GetNotificationId()) {
185 CheckCaseSeventeenResult(notificationRequest);
186 } else if (CASE_TWENTY_ONE == notificationRequest.GetNotificationId()) {
187 CheckCaseTwentyOneResult(notificationRequest);
188 } else {
189 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish::OnConsumed do nothing!!!!!";
190 }
191 }
192
OnBadgeChanged(const std::shared_ptr<BadgeNumberCallbackData> & badgeData)193 void OnBadgeChanged(const std::shared_ptr<BadgeNumberCallbackData> &badgeData) override
194 {
195 GTEST_LOG_(INFO) << "ANS_Interface_MT::OnBadgeChanged badgeData : " << badgeData->Dump();
196 g_onBadgeNumberReceived = true;
197 EXPECT_EQ(badgeData->GetBadgeNumber(), BADGE_NUMBER);
198 }
199
OnBadgeEnabledChanged(const sptr<EnabledNotificationCallbackData> & callbackData)200 void OnBadgeEnabledChanged(
201 const sptr<EnabledNotificationCallbackData> &callbackData) override
202 {}
203
OnBatchCanceled(const std::vector<std::shared_ptr<Notification>> & requestList,const std::shared_ptr<NotificationSortingMap> & sortingMap,int32_t deleteReason)204 void OnBatchCanceled(const std::vector<std::shared_ptr<Notification>>
205 &requestList, const std::shared_ptr<NotificationSortingMap> &sortingMap, int32_t deleteReason) override
206 {}
207
208 private:
CheckCaseOneResult(NotificationRequest notificationRequest)209 void CheckCaseOneResult(NotificationRequest notificationRequest)
210 {
211 std::shared_ptr<NotificationContent> notificationContent = notificationRequest.GetContent();
212 if (notificationContent != nullptr) {
213 EXPECT_EQ(NotificationContent::Type::MEDIA, notificationContent->GetContentType());
214 std::shared_ptr<NotificationMediaContent> notificationMediaContent =
215 std::static_pointer_cast<NotificationMediaContent>(notificationContent->GetNotificationContent());
216 if (notificationMediaContent != nullptr) {
217 EXPECT_EQ(nullptr, notificationMediaContent->GetAVToken());
218 for (auto it : notificationMediaContent->GetShownActions()) {
219 EXPECT_EQ((uint32_t)0, it);
220 }
221 }
222 }
223 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
224 for (auto str : notificationRequest.GetNotificationUserInputHistory()) {
225 EXPECT_EQ("style", str);
226 }
227 EXPECT_EQ("bundleName", notificationRequest.GetOwnerBundleName());
228 EXPECT_EQ("bundleName", notificationRequest.GetCreatorBundleName());
229 EXPECT_EQ("ANS_Interface_MT_Publish_00100", notificationRequest.GetLabel());
230
231 // pixelmap
232 auto littleIcon = notificationRequest.GetLittleIcon();
233 Media::ImageInfo outImageInfo;
234 littleIcon->GetImageInfo(outImageInfo);
235 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100 :: littleIcon :: width : " << outImageInfo.size.width;
236 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100 :: littleIcon :: height : " << outImageInfo.size.height;
237
238 EXPECT_EQ(outImageInfo.size.width, PIXEL_MAP_TEST_WIDTH);
239 EXPECT_EQ(outImageInfo.size.height, PIXEL_MAP_TEST_HEIGHT);
240 EXPECT_EQ(outImageInfo.pixelFormat, Media::PixelFormat::ALPHA_8);
241 EXPECT_EQ(outImageInfo.colorSpace, Media::ColorSpace::SRGB);
242
243 EXPECT_NE(nullptr, notificationRequest.GetBigIcon());
244 EXPECT_NE(nullptr, notificationRequest.GetLittleIcon());
245 EXPECT_NE(nullptr, notificationRequest.GetOverlayIcon());
246 std::vector<std::shared_ptr<MessageUser>> messageUser = notificationRequest.GetMessageUsers();
247 for (auto user : messageUser) {
248 if (user != nullptr) {
249 EXPECT_EQ("ANS_Interface_MT_Publish_00100_Message_User", user->GetName());
250 EXPECT_EQ("key", user->GetKey());
251 EXPECT_EQ(nullptr, user->GetPixelMap());
252 EXPECT_EQ(Uri("."), user->GetUri());
253 EXPECT_EQ(false, user->IsMachine());
254 EXPECT_EQ(false, user->IsUserImportant());
255 }
256 }
257 }
258
CheckCaseTwoResult(NotificationRequest notificationRequest)259 void CheckCaseTwoResult(NotificationRequest notificationRequest)
260 {
261 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
262 std::vector<std::shared_ptr<NotificationActionButton>> actionButtons = notificationRequest.GetActionButtons();
263 for (auto actionButton : actionButtons) {
264 std::shared_ptr<NotificationUserInput> userInput = actionButton->GetUserInput();
265 EXPECT_EQ(NotificationConstant::FREE_FORM_INPUT, userInput->GetInputsSource(g_want));
266 EXPECT_EQ(nullptr, userInput->GetInputsFromWant(g_want));
267 std::map<std::string, std::shared_ptr<Uri>> map = userInput->GetMimeInputsFromWant(g_want, "");
268 EXPECT_EQ(unsigned(0), map.size());
269 EXPECT_EQ("inputKey", userInput->GetInputKey());
270 EXPECT_NE(nullptr, userInput->GetAdditionalData());
271 EXPECT_EQ(NotificationConstant::InputEditType::EDIT_DISABLED, userInput->GetEditType());
272 for (auto option : userInput->GetOptions()) {
273 EXPECT_EQ("", option);
274 }
275 for (auto type : userInput->GetPermitMimeTypes()) {
276 EXPECT_EQ("mimeType", type);
277 }
278 EXPECT_EQ(false, userInput->IsMimeTypeOnly());
279 EXPECT_EQ("tag", userInput->GetTag());
280 EXPECT_EQ(false, userInput->IsPermitFreeFormInput());
281 }
282 }
283
CheckCaseThreeResult(NotificationRequest notificationRequest)284 void CheckCaseThreeResult(NotificationRequest notificationRequest)
285 {
286 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
287 std::vector<std::shared_ptr<NotificationActionButton>> actionButtons = notificationRequest.GetActionButtons();
288 for (auto actionButton : actionButtons) {
289 EXPECT_EQ(nullptr, actionButton->GetIcon());
290 EXPECT_EQ("title", actionButton->GetTitle());
291 EXPECT_EQ(nullptr, actionButton->GetWantAgent());
292 EXPECT_NE(nullptr, actionButton->GetAdditionalData());
293 EXPECT_EQ(NotificationConstant::NONE_ACTION_BUTTON, actionButton->GetSemanticActionButton());
294 for (auto userInputs : actionButton->GetMimeTypeOnlyUserInputs()) {
295 EXPECT_EQ("onlyUserInputKey", userInputs->GetInputKey());
296 }
297 EXPECT_EQ(true, actionButton->IsAutoCreatedReplies());
298 EXPECT_EQ(true, actionButton->IsContextDependent());
299 }
300 }
301
CheckCaseFourResult(NotificationRequest notificationRequest)302 void CheckCaseFourResult(NotificationRequest notificationRequest)
303 {
304 std::shared_ptr<NotificationContent> notificationContent = notificationRequest.GetContent();
305 if (notificationContent != nullptr) {
306 EXPECT_EQ(NotificationContent::Type::CONVERSATION, notificationContent->GetContentType());
307 std::shared_ptr<NotificationConversationalContent> notificationConversationContent =
308 std::static_pointer_cast<NotificationConversationalContent>(
309 notificationContent->GetNotificationContent());
310 if (notificationConversationContent != nullptr) {
311 EXPECT_EQ("ConversationTitle", notificationConversationContent->GetConversationTitle());
312 EXPECT_EQ(false, notificationConversationContent->IsConversationGroup());
313 std::vector<std::shared_ptr<NotificationConversationalMessage>> messagesPtr =
314 notificationConversationContent->GetAllConversationalMessages();
315 EXPECT_EQ(unsigned(CASE_TWO), messagesPtr.size());
316 MessageUser user = notificationConversationContent->GetMessageUser();
317 EXPECT_EQ("key", user.GetKey());
318 EXPECT_EQ("Name", user.GetName());
319 EXPECT_EQ(nullptr, user.GetPixelMap());
320 EXPECT_EQ(Uri("."), user.GetUri());
321 EXPECT_EQ(false, user.IsUserImportant());
322 EXPECT_EQ(false, user.IsMachine());
323 }
324 }
325 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
326 }
327
CheckCaseFiveResult(NotificationRequest notificationRequest)328 void CheckCaseFiveResult(NotificationRequest notificationRequest)
329 {
330 std::shared_ptr<NotificationContent> notificationContent = notificationRequest.GetContent();
331 if (notificationContent != nullptr) {
332 EXPECT_EQ(NotificationContent::Type::MULTILINE, notificationContent->GetContentType());
333 std::shared_ptr<NotificationMultiLineContent> notificationMultineContent =
334 std::static_pointer_cast<NotificationMultiLineContent>(notificationContent->GetNotificationContent());
335 if (notificationMultineContent != nullptr) {
336 EXPECT_EQ("expandedtitle", notificationMultineContent->GetExpandedTitle());
337 EXPECT_EQ("brieftext", notificationMultineContent->GetBriefText());
338 for (auto allLine : notificationMultineContent->GetAllLines()) {
339 EXPECT_EQ("singleLine", allLine);
340 }
341 }
342 }
343 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
344 }
345
CheckCaseSixResult(NotificationRequest notificationRequest)346 void CheckCaseSixResult(NotificationRequest notificationRequest)
347 {
348 std::shared_ptr<NotificationContent> notificationContent = notificationRequest.GetContent();
349 if (notificationContent != nullptr) {
350 EXPECT_EQ(NotificationContent::Type::PICTURE, notificationContent->GetContentType());
351 std::shared_ptr<NotificationPictureContent> notificationPictureContent =
352 std::static_pointer_cast<NotificationPictureContent>(notificationContent->GetNotificationContent());
353 if (notificationPictureContent != nullptr) {
354 EXPECT_EQ("expendedtitle", notificationPictureContent->GetExpandedTitle());
355 EXPECT_EQ("brieftext", notificationPictureContent->GetBriefText());
356 EXPECT_EQ(nullptr, notificationPictureContent->GetBigPicture());
357 }
358 }
359 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
360 }
361
CheckCaseSevenResult(NotificationRequest notificationRequest)362 void CheckCaseSevenResult(NotificationRequest notificationRequest)
363 {
364 std::shared_ptr<NotificationContent> notificationContent = notificationRequest.GetContent();
365 if (notificationContent != nullptr) {
366 EXPECT_EQ(NotificationContent::Type::LONG_TEXT, notificationContent->GetContentType());
367 std::shared_ptr<NotificationLongTextContent> notificationLongContent =
368 std::static_pointer_cast<NotificationLongTextContent>(notificationContent->GetNotificationContent());
369 if (notificationLongContent != nullptr) {
370 EXPECT_EQ("expendedtitle", notificationLongContent->GetExpandedTitle());
371 EXPECT_EQ("brieftext", notificationLongContent->GetBriefText());
372 EXPECT_EQ("longtext", notificationLongContent->GetLongText());
373 }
374 }
375 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
376 }
377
CheckCaseEightResult(NotificationRequest notificationRequest)378 void CheckCaseEightResult(NotificationRequest notificationRequest)
379 {
380 EXPECT_EQ(NotificationConstant::CONTENT_INFORMATION, notificationRequest.GetSlotType());
381 EXPECT_EQ(false, notificationRequest.IsInProgress());
382 EXPECT_EQ(false, notificationRequest.IsUnremovable());
383 EXPECT_EQ(0, notificationRequest.GetBadgeNumber());
384 EXPECT_NE(0, notificationRequest.GetDeliveryTime());
385 EXPECT_EQ(false, notificationRequest.IsShowDeliveryTime());
386 EXPECT_EQ(false, notificationRequest.IsPermitSystemGeneratedContextualActionButtons());
387 EXPECT_EQ(false, notificationRequest.IsAlertOneTime());
388 EXPECT_EQ(0, notificationRequest.GetAutoDeletedTime());
389 EXPECT_EQ("classification", notificationRequest.GetClassification());
390 EXPECT_EQ((uint32_t)0, notificationRequest.GetColor());
391 }
392
CheckCaseNineResult(NotificationRequest notificationRequest)393 void CheckCaseNineResult(NotificationRequest notificationRequest)
394 {
395 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
396 EXPECT_EQ(false, notificationRequest.IsColorEnabled());
397 EXPECT_EQ(false, notificationRequest.IsCountdownTimer());
398 EXPECT_EQ("groupvalue", notificationRequest.GetGroupName());
399 EXPECT_EQ(true, notificationRequest.IsOnlyLocal());
400 EXPECT_EQ("setting text", notificationRequest.GetSettingsText());
401 EXPECT_EQ(false, notificationRequest.IsShowStopwatch());
402 EXPECT_EQ("sortingkey", notificationRequest.GetSortingKey());
403 EXPECT_EQ("statusbartext", notificationRequest.GetStatusBarText());
404 EXPECT_EQ(false, notificationRequest.IsTapDismissed());
405 auto visibleness = notificationRequest.GetVisibleness();
406 EXPECT_EQ((int)NotificationConstant::VisiblenessType::PUBLIC, (int)visibleness);
407 EXPECT_EQ(NotificationRequest::BadgeStyle::NONE, notificationRequest.GetBadgeIconStyle());
408 EXPECT_EQ("shortcutid", notificationRequest.GetShortcutId());
409 EXPECT_EQ(false, notificationRequest.IsFloatingIcon());
410 EXPECT_EQ(0, notificationRequest.GetProgressMax());
411 EXPECT_EQ(0, notificationRequest.GetProgressValue());
412 EXPECT_EQ(false, notificationRequest.IsProgressIndeterminate());
413 EXPECT_EQ(1, notificationRequest.GetBadgeNumber());
414 }
415
CheckCaseFourteenResult(const NotificationRequest & notificationRequest) const416 void CheckCaseFourteenResult(const NotificationRequest& notificationRequest) const
417 {
418 std::shared_ptr<NotificationTemplate> notiTemplate = notificationRequest.GetTemplate();
419 if (notiTemplate != nullptr) {
420 EXPECT_EQ("downloadTemplate1", notiTemplate->GetTemplateName());
421 std::shared_ptr<AAFwk::WantParams> param = notiTemplate->GetTemplateData();
422 int value = AAFwk::Integer::Unbox(AAFwk::IInteger::Query(param->GetParam("downloadTemplate1")));
423 EXPECT_EQ(20, value); // 20 test input
424 }
425 EXPECT_EQ(NotificationConstant::OTHER, notificationRequest.GetSlotType());
426 }
427
CheckCaseFifteenResult(NotificationRequest notificationRequest)428 void CheckCaseFifteenResult(NotificationRequest notificationRequest)
429 {
430 std::shared_ptr<NotificationFlags> notiFlags = notificationRequest.GetFlags();
431 if (notiFlags != nullptr) {
432 EXPECT_EQ(NotificationConstant::FlagStatus::NONE, notiFlags->IsSoundEnabled());
433 EXPECT_EQ(NotificationConstant::FlagStatus::NONE, notiFlags->IsVibrationEnabled());
434 }
435 }
436
CheckCaseSixteenResult(NotificationRequest notificationRequest)437 void CheckCaseSixteenResult(NotificationRequest notificationRequest)
438 {
439 std::shared_ptr<NotificationFlags> notiFlags = notificationRequest.GetFlags();
440 if (notiFlags != nullptr) {
441 EXPECT_EQ(NotificationConstant::FlagStatus::CLOSE, notiFlags->IsSoundEnabled());
442 EXPECT_EQ(NotificationConstant::FlagStatus::CLOSE, notiFlags->IsVibrationEnabled());
443 }
444 }
445
CheckCaseSeventeenResult(NotificationRequest notificationRequest)446 void CheckCaseSeventeenResult(NotificationRequest notificationRequest)
447 {
448 std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> removalWantAgent =
449 notificationRequest.GetRemovalWantAgent();
450 EXPECT_NE(removalWantAgent, nullptr);
451 }
452
CheckCaseTwentyOneResult(NotificationRequest notificationRequest)453 void CheckCaseTwentyOneResult(NotificationRequest notificationRequest)
454 {
455 std::shared_ptr<NotificationFlags> notiFlags = notificationRequest.GetFlags();
456 if (notiFlags != nullptr) {
457 EXPECT_EQ(NotificationConstant::FlagStatus::NONE, notiFlags->IsSoundEnabled());
458 EXPECT_EQ(NotificationConstant::FlagStatus::NONE, notiFlags->IsVibrationEnabled());
459 }
460 }
461 };
462
463 class CompletedCallbackTest : public AbilityRuntime::WantAgent::CompletedCallback {
OnSendFinished(const AAFwk::Want & want,int resultCode,const std::string & resultData,const AAFwk::WantParams & resultExtras)464 void OnSendFinished(
465 const AAFwk::Want &want, int resultCode, const std::string &resultData, const AAFwk::WantParams &resultExtras)
466 {
467 (void)want;
468 (void)resultCode;
469 (void)resultData;
470 (void)resultExtras;
471
472 g_send_finished_mtx.unlock();
473 g_onWantReceived = true;
474 }
475 };
476
477 class AnsInnerKitsModulePublishTest : public testing::Test {
478 public:
479 static void SetUpTestCase();
480 static void TearDownTestCase();
481 void SetUp();
482 void TearDown();
483 void WaitOnSubscribeResult();
484 void WaitOnConsumed();
485 void WaitOnUnsubscribeResult();
486 void WaitOnResponse(int32_t notificationId, std::string buttonName);
487 void CheckJsonConverter(const NotificationRequest *request);
488
489 static sptr<AdvancedNotificationService> service_;
490 };
491
492 sptr<AdvancedNotificationService> AnsInnerKitsModulePublishTest::service_;
SetUpTestCase()493 void AnsInnerKitsModulePublishTest::SetUpTestCase()
494 {
495 RemoteNativeToken::SetNativeToken("ans_innerkits_module_publish_test");
496 service_ = OHOS::Notification::AdvancedNotificationService::GetInstance();
497 OHOS::ISystemAbilityManager::SAExtraProp saExtraProp;
498 systemAbilityManager->AddSystemAbility(OHOS::ADVANCED_NOTIFICATION_SERVICE_ABILITY_ID, service_, saExtraProp);
499 }
500
TearDownTestCase()501 void AnsInnerKitsModulePublishTest::TearDownTestCase()
502 {
503 if (service_ != nullptr) {
504 service_->SelfClean();
505 }
506 }
507
SetUp()508 void AnsInnerKitsModulePublishTest::SetUp()
509 {
510 MockGetTokenTypeFlag(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP);
511 }
512
TearDown()513 void AnsInnerKitsModulePublishTest::TearDown()
514 {
515 g_onConsumedReceived = false;
516 g_subscribe_mtx.unlock();
517 g_consumed_mtx.unlock();
518 g_unsubscribe_mtx.unlock();
519 }
520
WaitOnSubscribeResult()521 void AnsInnerKitsModulePublishTest::WaitOnSubscribeResult()
522 {
523 struct tm subscribeTime = {0};
524 EXPECT_EQ(OHOS::GetSystemCurrentTime(&subscribeTime), true);
525 struct tm subscribeDoingTime = {0};
526 EXPECT_EQ(OHOS::GetSystemCurrentTime(&subscribeDoingTime), true);
527 int64_t subscribeSeconds = 0;
528 while (!g_subscribe_mtx.try_lock()) {
529 EXPECT_EQ(OHOS::GetSystemCurrentTime(&subscribeDoingTime), true);
530 subscribeSeconds = OHOS::GetSecondsBetween(subscribeTime, subscribeDoingTime);
531 if (subscribeSeconds >= TIME_OUT_SECONDS_LIMIT) {
532 GTEST_LOG_(INFO) << "g_subscribe_mtx.try_lock overtime";
533 break;
534 }
535 }
536 }
537
WaitOnConsumed()538 void AnsInnerKitsModulePublishTest::WaitOnConsumed()
539 {
540 struct tm publishTime = {0};
541 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishTime), true);
542 struct tm publishDoingTime = {0};
543 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishDoingTime), true);
544 int64_t publishSeconds = 0;
545 while (!g_consumed_mtx.try_lock()) {
546 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishDoingTime), true);
547 publishSeconds = OHOS::GetSecondsBetween(publishTime, publishDoingTime);
548 if (publishSeconds >= TIME_OUT_SECONDS_LIMIT) {
549 GTEST_LOG_(INFO) << "g_consumed_mtx.try_lock overtime";
550 break;
551 }
552 }
553 EXPECT_EQ(g_onConsumedReceived, true);
554 }
555
WaitOnUnsubscribeResult()556 void AnsInnerKitsModulePublishTest::WaitOnUnsubscribeResult()
557 {
558 struct tm unsubscribeTime = {0};
559 EXPECT_EQ(OHOS::GetSystemCurrentTime(&unsubscribeTime), true);
560 struct tm unsubscribeDoingTime = {0};
561 EXPECT_EQ(OHOS::GetSystemCurrentTime(&unsubscribeDoingTime), true);
562 int64_t unSubscribeseconds = 0;
563 while (!g_unsubscribe_mtx.try_lock()) {
564 EXPECT_EQ(OHOS::GetSystemCurrentTime(&unsubscribeTime), true);
565 unSubscribeseconds = OHOS::GetSecondsBetween(unsubscribeTime, unsubscribeDoingTime);
566 if (unSubscribeseconds >= TIME_OUT_SECONDS_LIMIT) {
567 GTEST_LOG_(INFO) << "Ag_unsubscribe_mtx.try_lock overtime";
568 break;
569 }
570 }
571 }
572
WaitOnResponse(int32_t notificationId,std::string buttonName)573 void AnsInnerKitsModulePublishTest::WaitOnResponse(int32_t notificationId, std::string buttonName)
574 {
575 struct tm publishTime = {0};
576 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishTime), true);
577 struct tm publishDoingTime = {0};
578 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishDoingTime), true);
579 int64_t publishSeconds = 0;
580 while (!g_system_live_view_subscribe_response_mtx.try_lock()) {
581 EXPECT_EQ(OHOS::GetSystemCurrentTime(&publishDoingTime), true);
582 publishSeconds = OHOS::GetSecondsBetween(publishTime, publishDoingTime);
583 if (publishSeconds >= TIME_OUT_SECONDS_LIMIT) {
584 GTEST_LOG_(INFO) << "g_system_live_view_subscribe_response_mtx.try_lock overtime";
585 break;
586 }
587 }
588 EXPECT_EQ(g_onResponseReceivedButtonName, buttonName);
589 EXPECT_EQ(g_onResponseReceivedId, notificationId);
590 }
591
CheckJsonConverter(const NotificationRequest * request)592 void AnsInnerKitsModulePublishTest::CheckJsonConverter(const NotificationRequest *request)
593 {
594 nlohmann::json jsonObject;
595 auto ret0 = NotificationJsonConverter::ConvertToJson(request, jsonObject);
596 EXPECT_EQ(ret0, true);
597 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertToJson object dump ==========>" << jsonObject.dump();
598
599 std::string jsonString;
600 auto ret1 = NotificationJsonConverter::ConvertToJsonString(request, jsonString);
601 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertToJsonString ret1 ==========>"
602 << (ret1 ? "true" : "false");
603 EXPECT_EQ(ret1, true);
604 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertToJsonString string ==========>" << jsonString;
605
606 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::convert Json sleep start ==========>";
607 sleep(SLEEP_TIME);
608 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::convert Json sleep end ==========>";
609
610 auto pRequest1 = NotificationJsonConverter::ConvertFromJson<NotificationRequest>(jsonObject);
611 EXPECT_NE(pRequest1, nullptr);
612 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertFromJson jsonObject dump request ==========>"
613 << pRequest1->Dump();
614
615 auto pRequest2 = NotificationJsonConverter::ConvertFromJsonString<NotificationRequest>(jsonString);
616 EXPECT_NE(pRequest2, nullptr);
617 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertFromJsonString jsonString dump request ==========>"
618 << pRequest2->Dump();
619
620 nlohmann::json jsonObject2;
621 auto ret2 = NotificationJsonConverter::ConvertToJson(pRequest1, jsonObject2);
622 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::ConvertToJson ret2 ==========>" << (ret2 ? "true" : "false");
623 EXPECT_EQ(ret2, true);
624 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::FromJson -> ToJson object dump ==========>"
625 << jsonObject2.dump();
626 }
627
628 /**
629 * @tc.number : ANS_Interface_MT_Publish_00100
630 * @tc.name : Publish_00100
631 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a media notification.
632 * @tc.expected : Add notification slot success, make a subscriber and publish a media notification success.
633 */
634 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00100, Function | MediumTest | Level1)
635 {
636 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100 start ==========>";
637 NotificationSlot slot(NotificationConstant::OTHER);
638 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
639 auto subscriber = TestAnsSubscriber();
640 NotificationSubscribeInfo info = NotificationSubscribeInfo();
641 info.AddAppName("bundleName");
642 info.AddAppUserId(SUBSCRIBE_USER_ALL);
643 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100::SubscribeInfo:" << info.Dump();
644 g_subscribe_mtx.lock();
645 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
646 WaitOnSubscribeResult();
647 std::shared_ptr<NotificationMediaContent> mediaContent = std::make_shared<NotificationMediaContent>();
648 EXPECT_NE(mediaContent, nullptr);
649 mediaContent->SetAVToken(nullptr);
650 std::vector<uint32_t> actions;
651 actions.push_back(0);
652 mediaContent->SetShownActions(actions);
653 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100::mediaContent:" << mediaContent->Dump();
654 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(mediaContent);
655 EXPECT_NE(content, nullptr);
656 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100::Content:" << content->Dump();
657 NotificationRequest req;
658 req.SetContent(content);
659 req.SetSlotType(NotificationConstant::OTHER);
660 req.SetNotificationId(CASE_ONE);
661 std::vector<std::string> style;
662 style.push_back("style");
663 req.SetNotificationUserInputHistory(style);
664 req.SetOwnerBundleName("bundleName");
665 req.SetCreatorBundleName("creatorbundlename");
666 req.SetLabel("ANS_Interface_MT_Publish_00100");
667
668 // pixelmap
669 auto pixelMap = std::make_shared<Media::PixelMap>();
670 EXPECT_NE(pixelMap, nullptr);
671 Media::ImageInfo imageInfo;
672 imageInfo.size.width = PIXEL_MAP_TEST_WIDTH;
673 imageInfo.size.height = PIXEL_MAP_TEST_HEIGHT;
674 imageInfo.pixelFormat = Media::PixelFormat::ALPHA_8;
675 imageInfo.colorSpace = Media::ColorSpace::SRGB;
676 pixelMap->SetImageInfo(imageInfo);
677 int32_t rowDataSize = (PIXEL_MAP_TEST_WIDTH + 3) / 4 * 4;
678 uint32_t bufferSize = rowDataSize * PIXEL_MAP_TEST_HEIGHT;
679 void *buffer = malloc(bufferSize);
680 if (buffer != nullptr) {
681 pixelMap->SetPixelsAddr(buffer, nullptr, bufferSize, Media::AllocatorType::HEAP_ALLOC, nullptr);
682 }
683 EXPECT_NE(buffer, nullptr);
684
685 req.SetBigIcon(pixelMap);
686 req.SetLittleIcon(pixelMap);
687 req.SetOverlayIcon(pixelMap);
688 std::shared_ptr<MessageUser> messageUserPtr = std::make_shared<MessageUser>();
689 EXPECT_NE(messageUserPtr, nullptr);
690 messageUserPtr->SetName("ANS_Interface_MT_Publish_00100_Message_User");
691 messageUserPtr->SetKey("key");
692 messageUserPtr->SetPixelMap(nullptr);
693 messageUserPtr->SetUri(Uri("."));
694 messageUserPtr->SetMachine(false);
695 messageUserPtr->SetUserAsImportant(false);
696 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100::messageUser is::" << messageUserPtr->Dump();
697 req.AddMessageUser(messageUserPtr);
698 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00100::messageUser is::" << req.Dump();
699 g_consumed_mtx.lock();
700 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
701 WaitOnConsumed();
702 g_unsubscribe_mtx.lock();
703 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
704 WaitOnUnsubscribeResult();
705 }
706
707 /**
708 * @tc.number : ANS_Interface_MT_Publish_00200
709 * @tc.name : Publish_00200
710 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local notification with input
711 * box.
712 * @tc.expected : Add notification slot success, make a subscriber and publish a local notification with input box
713 * success.
714 */
715 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00200, Function | MediumTest | Level1)
716 {
717 NotificationSlot slot(NotificationConstant::OTHER);
718 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
719 auto subscriber = TestAnsSubscriber();
720 NotificationSubscribeInfo info = NotificationSubscribeInfo();
721 info.AddAppName("bundleName");
722 info.AddAppUserId(SUBSCRIBE_USER_ALL);
723 g_subscribe_mtx.lock();
724 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
725 WaitOnSubscribeResult();
726 std::shared_ptr<NotificationMediaContent> mediaContent = std::make_shared<NotificationMediaContent>();
727 EXPECT_NE(mediaContent, nullptr);
728 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(mediaContent);
729 EXPECT_NE(content, nullptr);
730 AbilityRuntime::WantAgent::WantAgentInfo paramsInfo;
731 std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> wantAgent =
732 AbilityRuntime::WantAgent::WantAgentHelper::GetWantAgent(paramsInfo);
733 std::shared_ptr<NotificationActionButton> actionButton =
734 NotificationActionButton::Create(nullptr, "title", wantAgent);
735 std::shared_ptr<NotificationUserInput> userInput = NotificationUserInput::Create("inputKey");
736 std::vector<std::shared_ptr<NotificationUserInput>> userInputs;
737 AAFwk::WantParams additional;
738 std::map<std::string, std::shared_ptr<Uri>> results;
739 std::vector<std::string> options;
740 std::set<std::string> permitMimeTypes;
741 std::shared_ptr<AAFwk::WantParams> additionalPtr;
742 userInput->SetInputsSource(g_want, NotificationConstant::FREE_FORM_INPUT);
743 userInput->AddInputsToWant(userInputs, g_want, additional);
744 std::shared_ptr<NotificationUserInput> userInputMine = NotificationUserInput::Create(
745 "Key", "tag", options, false, permitMimeTypes, additionalPtr, NotificationConstant::EDIT_AUTO);
746 userInput->AddMimeInputToWant(*userInputMine, g_want, results);
747 userInput->AddAdditionalData(additional);
748 userInput->SetEditType(NotificationConstant::EDIT_DISABLED);
749 userInput->SetOptions(options);
750 userInput->SetPermitMimeTypes("mimeType", false);
751 userInput->SetTag("tag");
752 userInput->SetPermitFreeFormInput(false);
753 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00200::userInput is::" << userInput->Dump();
754 actionButton->AddNotificationUserInput(userInput);
755 NotificationRequest req;
756 req.SetContent(content);
757 req.SetSlotType(NotificationConstant::OTHER);
758 req.AddActionButton(actionButton);
759 req.SetNotificationId(CASE_TWO);
760 req.SetOwnerBundleName("bundleName");
761 g_consumed_mtx.lock();
762 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
763 WaitOnConsumed();
764 g_unsubscribe_mtx.lock();
765 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
766 WaitOnUnsubscribeResult();
767 }
768
769 /**
770 * @tc.number : ANS_Interface_MT_Publish_00300
771 * @tc.name : Publish_00300
772 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local notification with
773 * ActionButton.
774 * @tc.expected : Add notification slot success, make a subscriber and publish a local notification with ActionButton
775 * success.
776 */
777 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00300, Function | MediumTest | Level1)
778 {
779 NotificationSlot slot(NotificationConstant::OTHER);
780 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
781 auto subscriber = TestAnsSubscriber();
782 NotificationSubscribeInfo info = NotificationSubscribeInfo();
783 info.AddAppName("bundleName");
784 info.AddAppUserId(SUBSCRIBE_USER_ALL);
785 g_subscribe_mtx.lock();
786 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
787 WaitOnSubscribeResult();
788 std::shared_ptr<NotificationMediaContent> mediaContent = std::make_shared<NotificationMediaContent>();
789 EXPECT_NE(mediaContent, nullptr);
790 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(mediaContent);
791 EXPECT_NE(content, nullptr);
792 AbilityRuntime::WantAgent::WantAgentInfo paramsInfo;
793 std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> wantAgent =
794 AbilityRuntime::WantAgent::WantAgentHelper::GetWantAgent(paramsInfo);
795 if (nullptr == wantAgent) {
796 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00300::wantAgent is nullptr";
797 }
798 std::shared_ptr<NotificationActionButton> actionButton =
799 NotificationActionButton::Create(nullptr, "title", wantAgent);
800 std::shared_ptr<NotificationUserInput> onlyUserInput = NotificationUserInput::Create("onlyUserInputKey");
801 AAFwk::WantParams additional;
802 actionButton->AddAdditionalData(additional);
803 actionButton->SetSemanticActionButton(NotificationConstant::NONE_ACTION_BUTTON);
804 actionButton->SetAutoCreatedReplies(true);
805 actionButton->AddMimeTypeOnlyUserInput(onlyUserInput);
806 actionButton->SetContextDependent(true);
807 GTEST_LOG_(INFO) << actionButton->Dump();
808 NotificationRequest req;
809 req.SetContent(content);
810 req.SetSlotType(NotificationConstant::OTHER);
811 req.AddActionButton(actionButton);
812 req.SetNotificationId(CASE_THREE);
813 req.SetOwnerBundleName("bundleName");
814 g_consumed_mtx.lock();
815 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
816 WaitOnConsumed();
817 g_unsubscribe_mtx.lock();
818 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
819 WaitOnUnsubscribeResult();
820 }
821
822 /**
823 * @tc.number : ANS_Interface_MT_Publish_00400
824 * @tc.name : Publish_00400
825 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local conversation
826 * notification.
827 * @tc.expected : Add notification slot success, make a subscriber and publish a local conversation notification
828 * success.
829 */
830 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00400, Function | MediumTest | Level1)
831 {
832 NotificationSlot slot(NotificationConstant::OTHER);
833 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
834 auto subscriber = TestAnsSubscriber();
835 NotificationSubscribeInfo info = NotificationSubscribeInfo();
836 info.AddAppName("bundleName");
837 info.AddAppUserId(SUBSCRIBE_USER_ALL);
838 g_subscribe_mtx.lock();
839 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
840 WaitOnSubscribeResult();
841 MessageUser messageUser, sender;
842 messageUser.SetKey("key");
843 messageUser.SetName("Name");
844 messageUser.SetPixelMap(nullptr);
845 messageUser.SetUri(Uri("."));
846 messageUser.SetUserAsImportant(false);
847 messageUser.SetMachine(false);
848 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00400::messgaeUser is::" << messageUser.Dump();
849 std::shared_ptr<NotificationConversationalContent> conversationContent =
850 std::make_shared<NotificationConversationalContent>(messageUser);
851 EXPECT_NE(conversationContent, nullptr);
852 conversationContent->SetConversationTitle("ConversationTitle");
853 conversationContent->SetConversationGroup(false);
854 conversationContent->AddConversationalMessage("text", 0, sender);
855 std::shared_ptr<NotificationConversationalMessage> messagePtr =
856 std::make_shared<NotificationConversationalMessage>("messageptr", 0, sender);
857 EXPECT_NE(messagePtr, nullptr);
858 conversationContent->AddConversationalMessage(messagePtr);
859 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00400::conversationContent is::" << conversationContent->Dump();
860 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(conversationContent);
861 EXPECT_NE(content, nullptr);
862 NotificationRequest req;
863 req.SetContent(content);
864 req.SetSlotType(NotificationConstant::OTHER);
865 req.SetNotificationId(CASE_FOUR);
866 req.SetOwnerBundleName("bundleName");
867 g_consumed_mtx.lock();
868 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
869 WaitOnConsumed();
870 g_unsubscribe_mtx.lock();
871 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
872 WaitOnUnsubscribeResult();
873 }
874
875 /**
876 * @tc.number : ANS_Interface_MT_Publish_00500
877 * @tc.name : Publish_00500
878 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local multiline notification.
879 * @tc.expected : Add notification slot success, make a subscriber and publish a local multiline notification success.
880 */
881 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00500, Function | MediumTest | Level1)
882 {
883 NotificationSlot slot(NotificationConstant::OTHER);
884 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
885 auto subscriber = TestAnsSubscriber();
886 NotificationSubscribeInfo info = NotificationSubscribeInfo();
887 info.AddAppName("bundleName");
888 info.AddAppUserId(SUBSCRIBE_USER_ALL);
889 g_subscribe_mtx.lock();
890 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
891 WaitOnSubscribeResult();
892 MessageUser messageUser;
893 std::shared_ptr<NotificationMultiLineContent> multiLineContent = std::make_shared<NotificationMultiLineContent>();
894 EXPECT_NE(multiLineContent, nullptr);
895 multiLineContent->SetExpandedTitle("expandedtitle");
896 multiLineContent->SetBriefText("brieftext");
897 multiLineContent->AddSingleLine("singleLine");
898 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00500::multiLineContent::" << multiLineContent->Dump();
899 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(multiLineContent);
900 EXPECT_NE(content, nullptr);
901 NotificationRequest req;
902 req.SetContent(content);
903 req.SetSlotType(NotificationConstant::OTHER);
904 req.SetNotificationId(CASE_FIVE);
905 req.SetOwnerBundleName("bundleName");
906 g_consumed_mtx.lock();
907 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
908 WaitOnConsumed();
909 g_unsubscribe_mtx.lock();
910 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
911 WaitOnUnsubscribeResult();
912 }
913
914 /**
915 * @tc.number : ANS_Interface_MT_Publish_00600
916 * @tc.name : Publish_00600
917 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local picture notification.
918 * @tc.expected : Add notification slot success, make a subscriber and publish a local picture notification success.
919 */
920 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00600, Function | MediumTest | Level1)
921 {
922 NotificationSlot slot(NotificationConstant::OTHER);
923 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
924 auto subscriber = TestAnsSubscriber();
925 NotificationSubscribeInfo info = NotificationSubscribeInfo();
926 info.AddAppName("bundleName");
927 info.AddAppUserId(SUBSCRIBE_USER_ALL);
928 g_subscribe_mtx.lock();
929 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
930 WaitOnSubscribeResult();
931 MessageUser messageUser;
932 std::shared_ptr<NotificationPictureContent> pictureContent = std::make_shared<NotificationPictureContent>();
933 EXPECT_NE(pictureContent, nullptr);
934 pictureContent->SetExpandedTitle("expendedtitle");
935 pictureContent->SetBriefText("brieftext");
936 pictureContent->SetBigPicture(nullptr);
937 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00600::pictureContent is::" << pictureContent->Dump();
938 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(pictureContent);
939 EXPECT_NE(content, nullptr);
940 NotificationRequest req;
941 req.SetContent(content);
942 req.SetSlotType(NotificationConstant::OTHER);
943 req.SetNotificationId(CASE_SIX);
944 req.SetOwnerBundleName("bundleName");
945 g_consumed_mtx.lock();
946 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
947 WaitOnConsumed();
948 g_unsubscribe_mtx.lock();
949 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
950 WaitOnUnsubscribeResult();
951 }
952
953 /**
954 * @tc.number : ANS_Interface_MT_Publish_00700
955 * @tc.name : Publish_00700
956 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local long text notification.
957 * @tc.expected : Add notification slot success, make a subscriber and publish a local long text notification success.
958 */
959 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00700, Function | MediumTest | Level1)
960 {
961 NotificationSlot slot(NotificationConstant::OTHER);
962 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
963 auto subscriber = TestAnsSubscriber();
964 NotificationSubscribeInfo info = NotificationSubscribeInfo();
965 info.AddAppName("bundleName");
966 info.AddAppUserId(SUBSCRIBE_USER_ALL);
967 g_subscribe_mtx.lock();
968 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
969 WaitOnSubscribeResult();
970 MessageUser messageUser;
971 std::shared_ptr<NotificationLongTextContent> longTextContent =
972 std::make_shared<NotificationLongTextContent>("longtext");
973 EXPECT_NE(longTextContent, nullptr);
974 longTextContent->SetExpandedTitle("expendedtitle");
975 longTextContent->SetBriefText("brieftext");
976 longTextContent->SetLongText("longtext");
977 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00700::longTextContentis::" << longTextContent->Dump();
978 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(longTextContent);
979 EXPECT_NE(content, nullptr);
980 NotificationRequest req;
981 req.SetContent(content);
982 req.SetSlotType(NotificationConstant::OTHER);
983 req.SetNotificationId(CASE_SEVEN);
984 req.SetOwnerBundleName("bundleName");
985 g_consumed_mtx.lock();
986 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
987 WaitOnConsumed();
988 g_unsubscribe_mtx.lock();
989 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
990 WaitOnUnsubscribeResult();
991 }
992
993 /**
994 * @tc.number : ANS_Interface_MT_Publish_00800
995 * @tc.name : Publish_00800
996 * @tc.desc : Add notification slot(type is CONTENT_INFORMATION), make a subscriber and publish a local normal
997 * notification.
998 * @tc.expected : Add notification slot success, make a subscriber and publish a local normal notification success.
999 */
1000 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00800, Function | MediumTest | Level1)
1001 {
1002 NotificationSlot slot(NotificationConstant::CONTENT_INFORMATION);
1003 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1004 auto subscriber = TestAnsSubscriber();
1005 g_subscribe_mtx.lock();
1006 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1007 WaitOnSubscribeResult();
1008 MessageUser messageUser;
1009 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1010 EXPECT_NE(normalContent, nullptr);
1011 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00800::normalContentis::" << normalContent->Dump();
1012 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1013 EXPECT_NE(content, nullptr);
1014 NotificationRequest req;
1015 req.SetContent(content);
1016 req.SetSlotType(NotificationConstant::CONTENT_INFORMATION);
1017 req.SetNotificationId(CASE_EIGHT);
1018 req.SetInProgress(false);
1019 req.SetUnremovable(false);
1020 req.SetBadgeNumber(0);
1021 req.SetDeliveryTime(0);
1022 req.SetShowDeliveryTime(false);
1023 req.SetPermitSystemGeneratedContextualActionButtons(false);
1024 req.SetAlertOneTime(false);
1025 req.SetAutoDeletedTime(0);
1026 req.SetClassification("classification");
1027 req.SetColor(0);
1028 req.SetCreatorUserId(SUBSCRIBE_USER_SYSTEM_BEGIN);
1029 g_consumed_mtx.lock();
1030 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1031 WaitOnConsumed();
1032 g_unsubscribe_mtx.lock();
1033 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1034 WaitOnUnsubscribeResult();
1035 }
1036
1037 /**
1038 * @tc.number : ANS_Interface_MT_Publish_00900
1039 * @tc.name : Publish_00900
1040 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a local normal
1041 * notification.
1042 * @tc.expected : Add notification slot success, make a subscriber and publish a local normal notification success.
1043 */
1044 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_00900, Function | MediumTest | Level1)
1045 {
1046 NotificationSlot slot(NotificationConstant::OTHER);
1047 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1048 auto subscriber = TestAnsSubscriber();
1049 g_subscribe_mtx.lock();
1050 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1051 WaitOnSubscribeResult();
1052 MessageUser messageUser;
1053 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1054 EXPECT_NE(normalContent, nullptr);
1055 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1056 EXPECT_NE(content, nullptr);
1057 NotificationRequest req;
1058 req.SetContent(content);
1059 req.SetSlotType(NotificationConstant::OTHER);
1060 req.SetNotificationId(CASE_NINE);
1061 req.SetColorEnabled(false);
1062 req.SetCountdownTimer(false);
1063 req.SetGroupName("groupvalue");
1064 req.SetOnlyLocal(true);
1065 req.SetSettingsText("setting text");
1066 req.SetShowStopwatch(false);
1067 req.SetSortingKey("sortingkey");
1068 req.SetStatusBarText("statusbartext");
1069 req.SetTapDismissed(false);
1070 req.SetVisibleness(NotificationConstant::VisiblenessType::PUBLIC);
1071 req.SetBadgeIconStyle(NotificationRequest::BadgeStyle::NONE);
1072 req.SetShortcutId("shortcutid");
1073 req.SetFloatingIcon(false);
1074 req.SetProgressBar(0, 0, false);
1075 req.SetCreatorUserId(SUBSCRIBE_USER_SYSTEM_BEGIN);
1076 req.SetBadgeNumber(1);
1077 g_consumed_mtx.lock();
1078 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1079 WaitOnConsumed();
1080 g_unsubscribe_mtx.lock();
1081 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1082 WaitOnUnsubscribeResult();
1083 }
1084
1085 /**
1086 * @tc.number : ANS_Interface_MT_Publish_01000
1087 * @tc.name : Publish_01000
1088 * @tc.desc : Add notification slot(type is SERVICE_REMINDER), make a subscriber and publish a local normal
1089 * notification.
1090 * @tc.expected : Add notification slot success, make a subscriber and publish a local normal notification success.
1091 */
1092 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_01000, Function | MediumTest | Level1)
1093 {
1094 NotificationSlot slot(NotificationConstant::SERVICE_REMINDER);
1095 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1096 auto subscriber = TestAnsSubscriber();
1097 // Wait OnSubscribeResult
1098 g_subscribe_mtx.lock();
1099 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1100 WaitOnSubscribeResult();
1101 MessageUser messageUser;
1102 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1103 EXPECT_NE(normalContent, nullptr);
1104 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1105 EXPECT_NE(content, nullptr);
1106 NotificationRequest req;
1107 req.SetContent(content);
1108 req.SetSlotType(NotificationConstant::SERVICE_REMINDER);
1109 req.SetNotificationId(CASE_TEN);
1110 g_consumed_mtx.lock();
1111 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1112 WaitOnConsumed();
1113 g_unsubscribe_mtx.lock();
1114 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1115 WaitOnUnsubscribeResult();
1116 sleep(SLEEP_TIME);
1117 }
1118
1119 /**
1120 * @tc.number : ANS_Interface_MT_Publish_02000
1121 * @tc.name : Publish_02000
1122 * @tc.desc : Add notification slot(type is SOCIAL_COMMUNICATION), make a subscriber and publish a local normal
1123 * notification.
1124 * @tc.expected : Add notification slot success, make a subscriber and publish a local normal notification success.
1125 */
1126 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_02000, Function | MediumTest | Level1)
1127 {
1128 NotificationSlot slot(NotificationConstant::SOCIAL_COMMUNICATION);
1129 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1130 auto subscriber = TestAnsSubscriber();
1131 g_subscribe_mtx.lock();
1132 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1133 WaitOnSubscribeResult();
1134 MessageUser messageUser;
1135 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1136 EXPECT_NE(normalContent, nullptr);
1137 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1138 EXPECT_NE(content, nullptr);
1139 NotificationRequest req;
1140 req.SetContent(content);
1141 req.SetSlotType(NotificationConstant::SOCIAL_COMMUNICATION);
1142 req.SetNotificationId(CASE_ELEVEN);
1143 g_consumed_mtx.lock();
1144 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1145 WaitOnConsumed();
1146 g_unsubscribe_mtx.lock();
1147 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1148 WaitOnUnsubscribeResult();
1149 }
1150
1151 /**
1152 * @tc.number : ANS_Interface_MT_Publish_03000
1153 * @tc.name : Publish_03000
1154 * @tc.desc : Add notification slot(type is CUSTOM), make a subscriber and publish a local normal
1155 * notification.
1156 * @tc.expected : Add notification slot success, make a subscriber and publish a local normal notification success.
1157 */
1158 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_03000, Function | MediumTest | Level1)
1159 {
1160 NotificationSlot slot(NotificationConstant::CUSTOM);
1161 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1162 auto subscriber = TestAnsSubscriber();
1163 g_subscribe_mtx.lock();
1164 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1165 WaitOnSubscribeResult();
1166 MessageUser messageUser;
1167 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1168 EXPECT_NE(normalContent, nullptr);
1169 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1170 EXPECT_NE(content, nullptr);
1171 NotificationRequest req;
1172 req.SetContent(content);
1173 req.SetSlotType(NotificationConstant::CUSTOM);
1174 req.SetNotificationId(CASE_TWELVE);
1175 GTEST_LOG_(INFO) << "request is ::" << req.Dump();
1176 g_consumed_mtx.lock();
1177 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1178 WaitOnConsumed();
1179 g_unsubscribe_mtx.lock();
1180 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1181 WaitOnUnsubscribeResult();
1182 }
1183
1184 /**
1185 * @tc.number : ANS_Interface_MT_Publish_07000
1186 * @tc.name : Publish_07000
1187 * @tc.desc : Add notification slot(type is SOCIAL_COMMUNICATION), make a subscriber and publish a local group
1188 * notification.
1189 * @tc.expected : Add notification slot success, make a subscriber and publish a local group notification success.
1190 */
1191 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_07000, Function | MediumTest | Level1)
1192 {
1193 NotificationSlot slot(NotificationConstant::SOCIAL_COMMUNICATION);
1194 slot.EnableBypassDnd(true);
1195 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1196 auto subscriber = TestAnsSubscriber();
1197 g_subscribe_mtx.lock();
1198 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1199 WaitOnSubscribeResult();
1200 MessageUser messageUser;
1201 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1202 EXPECT_NE(normalContent, nullptr);
1203 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1204 EXPECT_NE(content, nullptr);
1205 NotificationRequest req;
1206 req.SetContent(content);
1207 req.SetSlotType(NotificationConstant::SOCIAL_COMMUNICATION);
1208 req.SetGroupName("groupnotifcation");
1209 req.SetGroupOverview(true);
1210 req.SetNotificationId(CASE_THIRTEEN);
1211 req.SetGroupAlertType(NotificationRequest::GroupAlertType::ALL);
1212 g_consumed_mtx.lock();
1213 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1214 WaitOnConsumed();
1215 g_unsubscribe_mtx.lock();
1216 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1217 WaitOnUnsubscribeResult();
1218 }
1219
1220 /**
1221 * @tc.number : ANS_FW_MT_GetActiveNotifications_00100
1222 * @tc.name : GetActiveNotifications_00100
1223 * @tc.desc : Get the active notifications and the number of active notifications of the current application.
1224 * @tc.expected : Get the active notifications success and the number of active notifications of the current
1225 * application is right.
1226 */
1227 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_GetActiveNotifications_00100, Function | MediumTest | Level1)
1228 {
1229 std::shared_ptr<NotificationLongTextContent> implContent = std::make_shared<NotificationLongTextContent>();
1230 EXPECT_NE(implContent, nullptr);
1231 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(implContent);
1232 EXPECT_NE(content, nullptr);
1233 EXPECT_EQ((int)ERR_OK, (int)NotificationHelper::CancelAllNotifications());
1234 uint64_t countBefor = 0;
1235 EXPECT_EQ((int)ERR_OK, NotificationHelper::GetActiveNotificationNums(countBefor));
1236 EXPECT_EQ(0, countBefor);
1237 std::string label1 = "Label1";
1238 NotificationRequest req1(0);
1239 req1.SetLabel(label1);
1240 req1.SetContent(content);
1241 req1.SetCreatorUserId(SUBSCRIBE_USER_SYSTEM_BEGIN);
1242 req1.SetCreatorUid(100);
1243
1244 EXPECT_EQ(0, NotificationHelper::PublishNotification(req1));
1245 std::string label2 = "Label2";
1246 NotificationRequest req2(0);
1247 req2.SetLabel(label2);
1248 req2.SetContent(content);
1249 req2.SetCreatorUserId(SUBSCRIBE_USER_SYSTEM_BEGIN);
1250 req2.SetCreatorUid(100);
1251 EXPECT_EQ(0, NotificationHelper::PublishNotification(req2));
1252 uint64_t countAfter = 0;
1253 EXPECT_EQ((int)ERR_OK, NotificationHelper::GetActiveNotificationNums(countAfter));
1254 EXPECT_EQ(ACTIVE_NUMS, countAfter);
1255 std::vector<sptr<NotificationRequest>> requests;
1256 EXPECT_EQ((int)ERR_OK, NotificationHelper::GetActiveNotifications(requests));
1257 EXPECT_EQ("Label1", requests[0]->GetLabel());
1258 EXPECT_EQ("Label2", requests[1]->GetLabel());
1259 EXPECT_EQ((int)ERR_OK, (int)NotificationHelper::RemoveNotifications(SUBSCRIBE_USER_SYSTEM_BEGIN));
1260 sleep(SLEEP_TIME);
1261 EXPECT_EQ((int)ERR_OK, NotificationHelper::GetActiveNotificationNums(countAfter));
1262 EXPECT_EQ(0, countAfter);
1263 }
1264
1265 /**
1266 * @tc.number : ANS_FW_MT_CancelGroup_10100
1267 * @tc.name : CancelGroup_10100
1268 * @tc.desc : Cancel the notifications of the same group.
1269 * @tc.expected : All notifications of the same group have been cancelled.
1270 */
1271 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_CancelGroup_10100, Function | MediumTest | Level1)
1272 {
1273 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1274 info.AddAppName("bundleName");
1275 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1276
1277 auto subscriber = TestAnsSubscriber();
1278 g_subscribe_mtx.lock();
1279 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1280 WaitOnSubscribeResult();
1281
1282 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1283 EXPECT_NE(normalContent, nullptr);
1284 GTEST_LOG_(INFO) << "ANS_Interface_MT_CancelGroup_10100::normalContentis::" << normalContent->Dump();
1285 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1286 EXPECT_NE(content, nullptr);
1287
1288 NotificationRequest req;
1289 req.SetContent(content);
1290 req.SetSlotType(NotificationConstant::OTHER);
1291 req.SetNotificationId(CANCELGROUP_NID);
1292 req.SetLabel("CancelGroup_10100");
1293 req.SetGroupName("group10100");
1294
1295 g_consumed_mtx.lock();
1296 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1297 WaitOnConsumed();
1298 g_onConsumedReceived = false;
1299
1300 GTEST_LOG_(INFO) << "ANS_Interface_MT_CancelGroup_10100:: call CancelGroup : effective parameters";
1301 EXPECT_EQ(0, NotificationHelper::CancelGroup("group10100"));
1302
1303 sleep(SLEEP_TIME);
1304 g_onCanceledReceived = false;
1305
1306 GTEST_LOG_(INFO) << "ANS_Interface_MT_CancelGroup_10100:: call CancelGroup : invalid parameters";
1307 EXPECT_EQ(0, NotificationHelper::CancelGroup("ngroup"));
1308
1309 sleep(SLEEP_TIME);
1310 g_onCanceledReceived = false;
1311
1312 req.SetOwnerBundleName("mybundlename");
1313 req.SetCreatorBundleName("mybundlename");
1314 g_consumed_mtx.unlock();
1315 g_consumed_mtx.lock();
1316 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1317 WaitOnConsumed();
1318 g_onConsumedReceived = false;
1319
1320 NotificationBundleOption bo("bundlename", 0);
1321 GTEST_LOG_(INFO) << "ANS_Interface_MT_CancelGroup_10100:: call RemoveGroupByBundle : effective parameters";
1322 EXPECT_EQ(0, NotificationHelper::RemoveGroupByBundle(bo, "group10100"));
1323
1324 sleep(SLEEP_TIME);
1325 g_onCanceledReceived = false;
1326
1327 GTEST_LOG_(INFO) << "ANS_Interface_MT_CancelGroup_10100:: call RemoveGroupByBundle : invalid parameters";
1328 EXPECT_EQ(0, NotificationHelper::RemoveGroupByBundle(bo, "ngroup"));
1329
1330 sleep(SLEEP_TIME);
1331 g_onCanceledReceived = false;
1332
1333 g_unsubscribe_mtx.lock();
1334 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1335 WaitOnUnsubscribeResult();
1336 }
1337
1338 /**
1339 * @tc.number : ANS_Interface_MT_Publish_04000
1340 * @tc.name : Publish_04000
1341 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a template notification.
1342 * @tc.expected : Add notification slot success, make a subscriber and publish a ltemplate notification success.
1343 */
1344 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_04000, Function | MediumTest | Level1)
1345 {
1346 NotificationSlot slot(NotificationConstant::OTHER);
1347 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1348 auto subscriber = TestAnsSubscriber();
1349 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1350 info.AddAppName("bundleName");
1351 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1352 g_subscribe_mtx.lock();
1353 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1354 WaitOnSubscribeResult();
1355
1356 std::shared_ptr<NotificationTemplate> notiTemplate = std::make_shared<NotificationTemplate>();
1357 EXPECT_NE(notiTemplate, nullptr);
1358 notiTemplate->SetTemplateName("downloadTemplate1");
1359
1360 AAFwk::WantParams wantParams;
1361 std::string key("downloadTemplate1");
1362 int resultValue = 20;
1363 wantParams.SetParam(key, AAFwk::Integer::Box(resultValue));
1364 wantParams.SetParam("fileName", AAFwk::Integer::Box(resultValue));
1365 wantParams.SetParam("title", AAFwk::Integer::Box(resultValue));
1366 notiTemplate->SetTemplateData(std::make_shared<AAFwk::WantParams>(wantParams));
1367 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_04000::notiTemplate::" << notiTemplate->Dump();
1368 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1369 EXPECT_NE(normalContent, nullptr);
1370 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1371 EXPECT_NE(content, nullptr);
1372 NotificationRequest req;
1373 req.SetContent(content);
1374 req.SetTemplate(notiTemplate);
1375 req.SetSlotType(NotificationConstant::OTHER);
1376 req.SetNotificationId(CASE_FOURTEEN);
1377 g_consumed_mtx.lock();
1378 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1379 WaitOnConsumed();
1380 g_unsubscribe_mtx.lock();
1381 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1382 WaitOnUnsubscribeResult();
1383 }
1384
1385 /**
1386 * @tc.number : ANS_Interface_MT_Publish_08000
1387 * @tc.name : Publish_08000
1388 * @tc.desc : .
1389 * @tc.expected : .
1390 */
1391 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_08000, Function | MediumTest | Level1)
1392 {
1393 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_08000::convert Json start ############==========>";
1394
1395 NotificationRequest req;
1396 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1397 EXPECT_NE(normalContent, nullptr);
1398 normalContent->SetTitle("normal_title");
1399 normalContent->SetText("normal_text");
1400 normalContent->SetAdditionalText("normal_additional_text");
1401 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_00800::normalContent::" << normalContent->Dump();
1402
1403 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1404 EXPECT_NE(content, nullptr);
1405
1406 req.SetNotificationId(8000);
1407 req.SetContent(content);
1408 req.SetSlotType(NotificationConstant::CONTENT_INFORMATION);
1409 req.SetClassification(NotificationRequest::CLASSIFICATION_ALARM);
1410 req.SetLabel("label");
1411 req.SetOwnerBundleName("owner");
1412
1413 auto wAgent1 = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
1414 req.SetWantAgent(wAgent1);
1415
1416 auto wAgent2 = std::make_shared<AbilityRuntime::WantAgent::WantAgent>();
1417 std::shared_ptr<Media::PixelMap> dummyIcon;
1418 auto ab1 = NotificationActionButton::Create(dummyIcon, "ab1_title", wAgent2);
1419
1420 auto spUserInput2 = NotificationUserInput::Create("uikey2");
1421 ab1->AddNotificationUserInput(spUserInput2);
1422 auto spOnlyUserInput1 = NotificationUserInput::Create("uionlykey1");
1423 spOnlyUserInput1->SetPermitFreeFormInput(false);
1424 spOnlyUserInput1->SetPermitMimeTypes("uionly", true);
1425 auto spOnlyUserInput4 = NotificationUserInput::Create("uionlykey4");
1426 spOnlyUserInput4->SetPermitFreeFormInput(false);
1427 spOnlyUserInput4->SetPermitMimeTypes("uionly", true);
1428
1429 ab1->AddMimeTypeOnlyUserInput(spOnlyUserInput1);
1430 ab1->AddMimeTypeOnlyUserInput(spOnlyUserInput4);
1431
1432 std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> dummyWantAgent;
1433 auto ab2 = NotificationActionButton::Create(dummyIcon, "ab2_title", dummyWantAgent);
1434
1435 req.AddActionButton(ab1);
1436 req.AddActionButton(ab2);
1437
1438 std::vector<std::string> history {"uihistory3", "uihistory2", "uihistory1"};
1439 req.SetNotificationUserInputHistory(history);
1440
1441 auto msgUser1 = std::make_shared<MessageUser>();
1442 msgUser1->SetKey("msgUser1_key");
1443 msgUser1->SetName("msgUser1_name");
1444 auto msgUser2 = std::make_shared<MessageUser>();
1445 msgUser2->SetKey("msgUser2_key");
1446 msgUser2->SetName("msgUser2_name");
1447 req.AddMessageUser(msgUser2);
1448 req.AddMessageUser(msgUser1);
1449
1450 CheckJsonConverter(&req);
1451 }
1452
1453 /**
1454 * @tc.number : ANS_Interface_MT_Publish_05000
1455 * @tc.name : Publish_05000
1456 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a flags notification.
1457 * @tc.expected : Add notification slot success, make a subscriber and publish a flags notification success.
1458 */
1459 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_05000, Function | MediumTest | Level1)
1460 {
1461 NotificationSlot slot(NotificationConstant::OTHER);
1462 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1463 auto subscriber = TestAnsSubscriber();
1464 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1465 info.AddAppName("bundleName");
1466 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1467 g_subscribe_mtx.lock();
1468 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1469 WaitOnSubscribeResult();
1470
1471 std::shared_ptr<NotificationFlags> notiFlags = std::make_shared<NotificationFlags>();
1472 EXPECT_NE(notiFlags, nullptr);
1473 notiFlags->SetSoundEnabled(NotificationConstant::FlagStatus::CLOSE);
1474 notiFlags->SetVibrationEnabled(NotificationConstant::FlagStatus::OPEN);
1475 GTEST_LOG_(INFO) << "ANS_Interface_MT_Publish_04000::flags::" << notiFlags->Dump();
1476 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1477 EXPECT_NE(normalContent, nullptr);
1478 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1479 EXPECT_NE(content, nullptr);
1480 NotificationRequest req;
1481 req.SetContent(content);
1482 req.SetFlags(notiFlags);
1483 req.SetNotificationId(CASE_FIFTEEN);
1484 g_consumed_mtx.lock();
1485 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1486 WaitOnConsumed();
1487 g_unsubscribe_mtx.lock();
1488 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1489 WaitOnUnsubscribeResult();
1490 }
1491
1492 /**
1493 * @tc.number : ANS_Interface_MT_Publish_06000
1494 * @tc.name : Publish_06000
1495 * @tc.desc : Add notification slot(type is OTHER), make a subscriber and publish a flags notification.
1496 * @tc.expected : Add notification slot success, make a subscriber and publish default flags notification success.
1497 */
1498 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_06000, Function | MediumTest | Level1)
1499 {
1500 NotificationSlot slot(NotificationConstant::OTHER);
1501 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1502 auto subscriber = TestAnsSubscriber();
1503 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1504 info.AddAppName("bundleName");
1505 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1506 g_subscribe_mtx.lock();
1507 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1508 WaitOnSubscribeResult();
1509
1510 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1511 EXPECT_NE(normalContent, nullptr);
1512 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1513 EXPECT_NE(content, nullptr);
1514 NotificationRequest req;
1515 req.SetContent(content);
1516 req.SetSlotType(NotificationConstant::OTHER);
1517 req.SetNotificationId(CASE_TWENTY_ONE);
1518 g_consumed_mtx.lock();
1519 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1520 WaitOnConsumed();
1521 g_unsubscribe_mtx.lock();
1522 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1523 WaitOnUnsubscribeResult();
1524 }
1525
1526 /**
1527 * @tc.number : ANS_Interface_MT_Slot_Enalbe_00100
1528 * @tc.name : Slot_Enalbe_00100
1529 * @tc.desc : Add notification slot(type is CONTENT_INFORMATION),
1530 * make a subscriber and publish a flags notification.
1531 * @tc.expected : Add notification slot success, make a subscriber and publish default flags notification success.
1532 */
1533 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Slot_Enalbe_00100, Function | MediumTest | Level1)
1534 {
1535 GTEST_LOG_(INFO) << "ANS_Interface_MT_Slot_Enalbe_00100::start:";
1536 NotificationSlot slot(NotificationConstant::CONTENT_INFORMATION);
1537 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1538
1539 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1540 EXPECT_NE(normalContent, nullptr);
1541 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1542 EXPECT_NE(content, nullptr);
1543 NotificationRequest req;
1544 req.SetContent(content);
1545 req.SetSlotType(NotificationConstant::CONTENT_INFORMATION);
1546 req.SetNotificationId(CASE_SIXTEEN);
1547 g_consumed_mtx.lock();
1548 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1549
1550 bool enable = false;
1551 NotificationBundleOption bo("bundleName", 1);
1552 EXPECT_EQ(0, NotificationHelper::SetEnabledForBundleSlot(
1553 bo, NotificationConstant::CONTENT_INFORMATION, enable, false));
1554 sleep(SLEEP_TIME);
1555 EXPECT_EQ(0, NotificationHelper::GetEnabledForBundleSlot(bo, NotificationConstant::CONTENT_INFORMATION, enable));
1556 GTEST_LOG_(INFO) << "ANS_Interface_MT_Slot_Enalbe_00100::end:" << enable;
1557 EXPECT_EQ(enable, false);
1558 EXPECT_EQ(ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_ENABLED, NotificationHelper::PublishNotification(req));
1559 EXPECT_EQ(0, NotificationHelper::SetEnabledForBundleSlot(
1560 bo, NotificationConstant::CONTENT_INFORMATION, true, false));
1561 }
1562
1563 /**
1564 * @tc.number : ANS_Interface_MT_Slot_Enalbe_00200
1565 * @tc.name : Slot_Enalbe_00200
1566 * @tc.desc : Add notification slot(type is SERVICE_REMINDER), make a subscriber and publish a flags notification.
1567 * @tc.expected : Add notification slot success, make a subscriber and publish default flags notification success.
1568 */
1569 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Slot_Enalbe_00200, Function | MediumTest | Level1)
1570 {
1571 GTEST_LOG_(INFO) << "ANS_Interface_MT_Slot_Enalbe_00200::start:";
1572 NotificationSlot slot(NotificationConstant::SERVICE_REMINDER);
1573 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1574
1575 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1576 EXPECT_NE(normalContent, nullptr);
1577 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1578 EXPECT_NE(content, nullptr);
1579 NotificationRequest req;
1580 req.SetContent(content);
1581 req.SetSlotType(NotificationConstant::SERVICE_REMINDER);
1582 req.SetNotificationId(CASE_SIXTEEN);
1583 g_consumed_mtx.lock();
1584 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1585
1586 bool enable = false;
1587 NotificationBundleOption bo("bundleName", 1);
1588 GTEST_LOG_(INFO) << "ANS_Interface_MT_Slot_Enalbe_00200::end:" << enable;
1589 EXPECT_EQ(0, NotificationHelper::SetEnabledForBundleSlot(
1590 bo, NotificationConstant::SERVICE_REMINDER, enable, false));
1591 sleep(SLEEP_TIME);
1592 EXPECT_EQ(0, NotificationHelper::GetEnabledForBundleSlot(bo, NotificationConstant::SERVICE_REMINDER, enable));
1593 EXPECT_EQ(enable, false);
1594 EXPECT_EQ((uint32_t)ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_ENABLED, NotificationHelper::PublishNotification(req));
1595
1596 enable = true;
1597 EXPECT_EQ(0, NotificationHelper::SetEnabledForBundleSlot(
1598 bo, NotificationConstant::SERVICE_REMINDER, enable, false));
1599 sleep(SLEEP_TIME);
1600 EXPECT_EQ(0, NotificationHelper::GetEnabledForBundleSlot(bo, NotificationConstant::SERVICE_REMINDER, enable));
1601 EXPECT_EQ(enable, true);
1602 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1603 }
1604
1605 /**
1606 * @tc.number : ANS_Interface_MT_Publish_09000
1607 * @tc.name : Publish_09000
1608 * @tc.desc : Add removalWantAgent, make a subscriber and publish a removalWantAgent notification.
1609 * @tc.expected : Add removalWantAgent success, make a subscriber and publish removalWantAgent notification success.
1610 */
1611 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_09000, Function | MediumTest | Level1)
1612 {
1613 NotificationSlot slot(NotificationConstant::OTHER);
1614 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1615 auto subscriber = TestAnsSubscriber();
1616 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1617 info.AddAppName("bundleName");
1618 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1619 g_subscribe_mtx.lock();
1620 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1621 WaitOnSubscribeResult();
1622
1623 std::shared_ptr<NotificationNormalContent> normalContent = std::make_shared<NotificationNormalContent>();
1624 EXPECT_NE(normalContent, nullptr);
1625 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(normalContent);
1626 EXPECT_NE(content, nullptr);
1627
1628 auto want = std::make_shared<OHOS::AAFwk::Want>();
1629 EXPECT_NE(want, nullptr);
1630 want->SetAction("usual.event.REMOVAL_WANTAGENT");
1631 AppExecFwk::ElementName element("device", "bundleName", "abilityName");
1632 want->SetElement(element);
1633 std::vector<std::shared_ptr<AAFwk::Want>> wants { want };
1634 std::vector<AbilityRuntime::WantAgent::WantAgentConstant::Flags> flags {
1635 AbilityRuntime::WantAgent::WantAgentConstant::Flags::CONSTANT_FLAG };
1636 AbilityRuntime::WantAgent::WantAgentInfo paramsInfo(
1637 10,
1638 AbilityRuntime::WantAgent::WantAgentConstant::OperationType::SEND_COMMON_EVENT,
1639 flags, wants, nullptr
1640 );
1641
1642 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
1643 std::make_shared<AbilityRuntime::ApplicationContext>();
1644 std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> wantAgent = nullptr;
1645 AbilityRuntime::WantAgent::WantAgentHelper::GetWantAgent(context, paramsInfo, wantAgent);
1646 EXPECT_NE(wantAgent, nullptr);
1647
1648 NotificationRequest req;
1649 req.SetContent(content);
1650 req.SetSlotType(NotificationConstant::OTHER);
1651 req.SetNotificationId(CASE_SEVENTEEN);
1652 req.SetRemovalWantAgent(wantAgent);
1653 g_consumed_mtx.lock();
1654 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1655 WaitOnConsumed();
1656 g_unsubscribe_mtx.lock();
1657 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1658 WaitOnUnsubscribeResult();
1659 }
1660
1661 /**
1662 * @tc.number : ANS_Interface_MT_Publish_10001
1663 * @tc.name : Publish_10001
1664 * @tc.desc : Add notification slot(type is LIVE_VIEW), make a subscriber, a system live view subscriber
1665 * and publish a system live view notification. Then trigger a button.
1666 * @tc.expected : Add notification slot success, publish notification failed because not subscirbe button callback .
1667 */
1668 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_10001, Function | MediumTest | Level1)
1669 {
1670 NotificationSlot slot(NotificationConstant::LIVE_VIEW);
1671 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1672 auto subscriber = TestAnsSubscriber();
1673 g_subscribe_mtx.lock();
1674 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1675 WaitOnSubscribeResult();
1676
1677 MessageUser messageUser;
1678 std::shared_ptr<NotificationLocalLiveViewContent> liveContent =
1679 std::make_shared<NotificationLocalLiveViewContent>();
1680 EXPECT_NE(liveContent, nullptr);
1681 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(liveContent);
1682 EXPECT_NE(content, nullptr);
1683
1684 NotificationRequest req;
1685 int32_t notificationId = CASE_EIGHTEEN;
1686 req.SetContent(content);
1687 req.SetSlotType(NotificationConstant::LIVE_VIEW);
1688 req.SetNotificationId(notificationId);
1689
1690 EXPECT_EQ(ERR_ANS_INVALID_PARAM, NotificationHelper::PublishNotification(req));
1691
1692 g_unsubscribe_mtx.lock();
1693 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1694 WaitOnUnsubscribeResult();
1695 }
1696
1697 /**
1698 * @tc.number : ANS_Interface_MT_Publish_10002
1699 * @tc.name : Publish_10002
1700 * @tc.desc : Add notification slot(type is LIVE_VIEW), make a subscriber, a system live view subscriber
1701 * and publish a system live view notification. Then trigger a button.
1702 * @tc.expected : Add notification slot success, make a subscriber, publish a notification
1703 * and trigger a buuton success.
1704 */
1705 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_Publish_10002, Function | MediumTest | Level1)
1706 {
1707 NotificationSlot slot(NotificationConstant::LIVE_VIEW);
1708 EXPECT_EQ(0, NotificationHelper::AddNotificationSlot(slot));
1709 auto subscriber = TestAnsSubscriber();
1710 g_subscribe_mtx.lock();
1711 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber));
1712 WaitOnSubscribeResult();
1713
1714 auto systemLiveViewSubscriber = TestLocalLiveViewSubscriber();
1715 EXPECT_EQ(0, NotificationHelper::SubscribeLocalLiveViewNotification(systemLiveViewSubscriber, true));
1716
1717 MessageUser messageUser;
1718 std::shared_ptr<NotificationLocalLiveViewContent> liveContent =
1719 std::make_shared<NotificationLocalLiveViewContent>();
1720 EXPECT_NE(liveContent, nullptr);
1721 std::shared_ptr<NotificationContent> content = std::make_shared<NotificationContent>(liveContent);
1722 EXPECT_NE(content, nullptr);
1723
1724 NotificationRequest req;
1725 int32_t notificationId = CASE_TWENTY;
1726 req.SetContent(content);
1727 req.SetSlotType(NotificationConstant::LIVE_VIEW);
1728 req.SetNotificationId(notificationId);
1729
1730 g_consumed_mtx.lock();
1731 EXPECT_EQ(0, NotificationHelper::PublishNotification(req));
1732 WaitOnConsumed();
1733
1734 std::string buttonName = "testButton";
1735 NotificationBundleOption bundleOption;
1736 bundleOption.SetBundleName("bundleName");
1737 bundleOption.SetUid(1);
1738 NotificationButtonOption buttonOption;
1739 buttonOption.SetButtonName(buttonName);
1740 g_system_live_view_subscribe_response_mtx.lock();
1741 EXPECT_EQ(0, NotificationHelper::TriggerLocalLiveView(bundleOption, notificationId, buttonOption));
1742 WaitOnResponse(notificationId, buttonName);
1743
1744 g_unsubscribe_mtx.lock();
1745 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber));
1746 WaitOnUnsubscribeResult();
1747 }
1748
1749 /**
1750 * @tc.name: ANS_Interface_MT_SetBadgeNumber_00100
1751 * @tc.desc: check SetBadgeNumber interface return value.
1752 * @tc.type: FUNC
1753 * @tc.require: #I6C2X9
1754 */
1755 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_SetBadgeNumber_00100, Function | MediumTest | Level1)
1756 {
1757 EXPECT_EQ(NotificationHelper::SetBadgeNumber(BADGE_NUMBER), (int)ERR_OK);
1758 }
1759
1760 /**
1761 * @tc.name: ANS_Interface_MT_SetBadgeNumber_00200
1762 * @tc.desc: check SetBadgeNumber interface return value.
1763 * @tc.type: FUNC
1764 * @tc.require: #I6C2X9
1765 */
1766 HWTEST_F(AnsInnerKitsModulePublishTest, ANS_Interface_MT_SetBadgeNumber_00200, Function | MediumTest | Level1)
1767 {
1768 auto subscriber = TestAnsSubscriber();
1769 NotificationSubscribeInfo info = NotificationSubscribeInfo();
1770 info.AddAppName("bundleName");
1771 info.AddAppUserId(SUBSCRIBE_USER_ALL);
1772 g_subscribe_mtx.lock();
1773 EXPECT_EQ(0, NotificationHelper::SubscribeNotification(subscriber, info));
1774 WaitOnSubscribeResult();
1775
1776 EXPECT_EQ(NotificationHelper::SetBadgeNumber(BADGE_NUMBER), (int)ERR_OK);
1777 sleep(SLEEP_TIME);
1778 EXPECT_EQ(g_onBadgeNumberReceived, true);
1779
1780 EXPECT_EQ(0, NotificationHelper::UnSubscribeNotification(subscriber, info));
1781 WaitOnUnsubscribeResult();
1782 }
1783 } // namespace Notification
1784 } // namespace OHOS
1785