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