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
16 #include "event_bus_test.h"
17
18 #include <memory>
19 #include <new>
20 #include <sys/time.h>
21
22 #include "distributed_hardware_log.h"
23 #include "event_bus.h"
24 #include "event_registration.h"
25
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace DistributedHardware {
30 namespace {
31 FakeObject *g_obj = nullptr;
32 FakeSender *g_sender = nullptr;
33 FakeListener *g_listener = nullptr;
34 std::shared_ptr<OHOS::DistributedHardware::EventRegistration> g_regHandler = nullptr;
35 EventBus* g_eventBus = nullptr;
36 const int32_t TEST_TWENTY_MS = 20000;
37 }
38
SetUpTestCase(void)39 void EventbusTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void EventbusTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void EventbusTest::SetUp()
48 {
49 g_obj = new(std::nothrow) FakeObject("Player");
50 if (g_obj == nullptr) {
51 DHLOGE("obj is null, because applying memory fail!");
52 return;
53 }
54 g_listener = new(std::nothrow) FakeListener();
55 if (g_listener == nullptr) {
56 DHLOGE("listener is null, because applying memory fail!");
57 return;
58 }
59 g_sender = new(std::nothrow) FakeSender();
60 if (g_sender == nullptr) {
61 DHLOGE("sender is null, because applying memory fail!");
62 return;
63 }
64 g_regHandler = nullptr;
65 g_eventBus = new(std::nothrow) EventBus();
66 if (g_eventBus == nullptr) {
67 DHLOGE("eventBus is null, because applying memory fail!");
68 return;
69 }
70 }
71
TearDown()72 void EventbusTest::TearDown()
73 {
74 usleep(TEST_TWENTY_MS);
75 if (g_obj != nullptr) {
76 delete g_obj;
77 g_obj = nullptr;
78 }
79 if (g_listener != nullptr) {
80 delete g_listener;
81 g_listener = nullptr;
82 }
83 if (g_sender != nullptr) {
84 delete g_sender;
85 g_sender = nullptr;
86 }
87 g_regHandler = nullptr;
88
89 if (g_eventBus != nullptr) {
90 delete g_eventBus;
91 g_eventBus = nullptr;
92 }
93 }
94
95 /**
96 * @tc.name: event_bus_test_001
97 * @tc.desc: Verify the EventBus AddHandler function.
98 * @tc.type: FUNC
99 * @tc.require: AR000GHSK9
100 */
101 HWTEST_F(EventbusTest, event_bus_test_001, TestSize.Level0)
102 {
103 EXPECT_EQ(g_regHandler, nullptr);
104
105 FakeEvent e(*g_sender, *g_obj);
106 g_regHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
107
108 EXPECT_NE(g_regHandler, nullptr);
109 EXPECT_EQ(g_regHandler->GetSender(), nullptr);
110 EXPECT_EQ(g_regHandler->GetHandler(), (void *)g_listener);
111 }
112
113 /**
114 * @tc.name: event_bus_test_002
115 * @tc.desc: Verify the EventBus AddHandler function.
116 * @tc.type: FUNC
117 * @tc.require: AR000GHSK9
118 */
119 HWTEST_F(EventbusTest, event_bus_test_002, TestSize.Level0)
120 {
121 EXPECT_EQ(g_regHandler, nullptr);
122
123 FakeEvent e(*g_sender, *g_obj);
124 g_regHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
125 std::shared_ptr<EventRegistration> secondHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
126
127 EXPECT_NE(secondHandler, nullptr);
128 EXPECT_EQ(g_regHandler, secondHandler);
129 }
130
131 /**
132 * @tc.name: event_bus_test_003
133 * @tc.desc: Verify the EventBus AddHandler with sender function.
134 * @tc.type: FUNC
135 * @tc.require: AR000GHSK9
136 */
137 HWTEST_F(EventbusTest, event_bus_test_003, TestSize.Level0)
138 {
139 EXPECT_EQ(g_regHandler, nullptr);
140
141 FakeEvent e(*g_sender, *g_obj);
142 g_regHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
143 std::shared_ptr<EventRegistration> secondHandler =
144 g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener, *g_sender);
145
146 EXPECT_NE(g_regHandler, nullptr);
147 EXPECT_NE(secondHandler, nullptr);
148 EXPECT_NE(g_regHandler, secondHandler);
149 EXPECT_EQ(secondHandler->GetSender(), g_sender);
150 EXPECT_EQ(secondHandler->GetHandler(), (void *)g_listener);
151 }
152
153 /**
154 * @tc.name: event_bus_test_004
155 * @tc.desc: Verify the EventBus AddHandler and RemoveHandler function.
156 * @tc.type: FUNC
157 * @tc.require: AR000GHSK9
158 */
159 HWTEST_F(EventbusTest, event_bus_test_004, TestSize.Level0)
160 {
161 EXPECT_EQ(g_regHandler, nullptr);
162 FakeEvent e(*g_sender, *g_obj);
163 EXPECT_EQ(false, g_eventBus->RemoveHandler<FakeEvent>(e.GetType(), g_regHandler));
164
165 g_regHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
166 EXPECT_EQ(true, g_eventBus->RemoveHandler<FakeEvent>(e.GetType(), g_regHandler));
167 }
168
169 /**
170 * @tc.name: event_bus_test_005
171 * @tc.desc: Verify the EventBus PostEvent function.
172 * @tc.type: FUNC
173 * @tc.require: AR000GHSK9
174 */
175 HWTEST_F(EventbusTest, event_bus_test_005, TestSize.Level0)
176 {
177 EXPECT_EQ(0, g_obj->GetAge());
178
179 FakeEvent e(*g_sender, *g_obj, 10);
180 g_regHandler = g_eventBus->AddHandler<FakeEvent>(e.GetType(), *g_listener);
181 g_eventBus->PostEvent<FakeEvent>(e, POSTMODE::POST_SYNC);
182 EXPECT_EQ(10, g_obj->GetAge());
183 }
184 } // namespace DistributedHardware
185 } // namespace OHOS
186