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