1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "eventcenter/event_center.h"
20
21 namespace OHOS::MiscServices {
22 using namespace testing::ext;
23 using namespace testing;
24 class EventCenterTest : public testing::Test {
25 public:
26 enum TestEventId {
27 TEST_EVT_UNKNOWN = Event::EVT_REMOTE_CHANGE,
28 TEST_EVT_BEGIN = Event::EVT_REMOTE_CHANGE + 1,
29 TEST_EVT_MIDDLE,
30 TEST_EVT_END,
31 };
32 class TestBegin : public Event {
33 public:
TestBegin()34 TestBegin() : Event(TEST_EVT_BEGIN){};
35 };
36 class TestMiddle : public Event {
37 public:
TestMiddle()38 TestMiddle() : Event(TEST_EVT_MIDDLE){};
39 };
40 class TestEnd : public Event {
41 public:
TestEnd()42 TestEnd() : Event(TEST_EVT_END){};
43 };
SetUpTestCase(void)44 static void SetUpTestCase(void) {}
TearDownTestCase(void)45 static void TearDownTestCase(void) {}
SetUp()46 void SetUp()
47 {
48 waitEvent_ = TEST_EVT_UNKNOWN;
49 currEvent_ = TEST_EVT_UNKNOWN;
50 EventCenter::GetInstance().Subscribe(TEST_EVT_BEGIN, [this](const Event &evt) {
51 ASSERT_EQ(waitEvent_, TEST_EVT_BEGIN);
52 EventCenter::Defer defer;
53 EventCenter::GetInstance().PostEvent(std::make_unique<TestMiddle>());
54 currEvent_ = TEST_EVT_BEGIN;
55 waitEvent_ = TEST_EVT_MIDDLE;
56 });
57 EventCenter::GetInstance().Subscribe(TEST_EVT_MIDDLE, [this](const Event &evt) {
58 ASSERT_EQ(waitEvent_, TEST_EVT_MIDDLE);
59 EventCenter::Defer defer;
60 EventCenter::GetInstance().PostEvent(std::make_unique<TestEnd>());
61 currEvent_ = TEST_EVT_MIDDLE;
62 waitEvent_ = TEST_EVT_END;
63 });
64 EventCenter::GetInstance().Subscribe(TEST_EVT_END, [this](const Event &evt) {
65 ASSERT_EQ(waitEvent_, TEST_EVT_END);
66 currEvent_ = TEST_EVT_END;
67 waitEvent_ = TEST_EVT_UNKNOWN;
68 });
69 }
70
TearDown()71 void TearDown()
72 {
73 EventCenter::GetInstance().Unsubscribe(TEST_EVT_BEGIN);
74 EventCenter::GetInstance().Unsubscribe(TEST_EVT_MIDDLE);
75 EventCenter::GetInstance().Unsubscribe(TEST_EVT_END);
76 waitEvent_ = TEST_EVT_UNKNOWN;
77 currEvent_ = TEST_EVT_UNKNOWN;
78 }
79
80 protected:
81 int32_t waitEvent_ = TEST_EVT_UNKNOWN;
82 int32_t currEvent_ = TEST_EVT_UNKNOWN;
83 };
84
85 /**
86 * @tc.name: TopLayerASyncEvent
87 * @tc.desc: the async event on the top layer will dispatch, until the function completed.
88 * @tc.type: FUNC
89 * @tc.require:
90 * @tc.author: Sven Wang
91 */
HWTEST_F(EventCenterTest, TopLayerASyncEvent, TestSize.Level2)92 HWTEST_F(EventCenterTest, TopLayerASyncEvent, TestSize.Level2)
93 {
94 auto test = [this]() {
95 EventCenter::Defer defer;
96 EventCenter::GetInstance().PostEvent(std::make_unique<TestBegin>());
97 waitEvent_ = TEST_EVT_BEGIN;
98 };
99 test();
100 ASSERT_EQ(currEvent_, TEST_EVT_END);
101 ASSERT_EQ(waitEvent_, TEST_EVT_UNKNOWN);
102 }
103
104 /**
105 * @tc.name: SubLayerASyncEvent
106 * @tc.desc: the async event on sub layer will defer to dispatch, until the top layer function completed.
107 * @tc.type: FUNC
108 * @tc.require:
109 * @tc.author: Sven Wang
110 */
HWTEST_F(EventCenterTest, SubLayerASyncEvent, TestSize.Level2)111 HWTEST_F(EventCenterTest, SubLayerASyncEvent, TestSize.Level2)
112 {
113 EventCenter::Defer defer;
114 EventCenter::GetInstance().PostEvent(std::make_unique<TestBegin>());
115 waitEvent_ = TEST_EVT_BEGIN;
116 ASSERT_EQ(currEvent_, TEST_EVT_UNKNOWN);
117 ASSERT_EQ(waitEvent_, TEST_EVT_BEGIN);
118 }
119
120 /**
121 * @tc.name: ASyncEventWithoutDefer
122 * @tc.desc: async event without defer may call or not
123 * @tc.type: FUNC
124 * @tc.require:
125 * @tc.author: Sven Wang
126 */
HWTEST_F(EventCenterTest, ASyncEventWithoutDefer, TestSize.Level2)127 HWTEST_F(EventCenterTest, ASyncEventWithoutDefer, TestSize.Level2)
128 {
129 EventCenter::Defer defer;
130 waitEvent_ = TEST_EVT_BEGIN;
131 auto test = [this]() {
132 EventCenter::GetInstance().PostEvent(std::make_unique<TestBegin>());
133 };
134 test();
135 ASSERT_EQ(currEvent_, TEST_EVT_UNKNOWN);
136 ASSERT_EQ(waitEvent_, TEST_EVT_BEGIN);
137 }
138
139 /**
140 * @tc.name: ImmediatelyASyncEvent
141 * @tc.desc: post the async event, there is top layer and no defer; we will dispatch the async event Immediately.
142 * @tc.type: FUNC
143 * @tc.require:
144 * @tc.author: Sven Wang
145 */
HWTEST_F(EventCenterTest, ImmediatelyASyncEvent, TestSize.Level2)146 HWTEST_F(EventCenterTest, ImmediatelyASyncEvent, TestSize.Level2)
147 {
148 waitEvent_ = TEST_EVT_BEGIN;
149 EventCenter::GetInstance().PostEvent(std::make_unique<TestBegin>());
150 ASSERT_EQ(currEvent_, TEST_EVT_END);
151 ASSERT_EQ(waitEvent_, TEST_EVT_UNKNOWN);
152 }
153 } // namespace OHOS::MiscServices