1 /*
2 * Copyright (c) 2022 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 <securec.h>
16 #include <gtest/gtest.h>
17
18 #include "softbus_adapter_mem.h"
19 #include "softbus_client_event_manager.c"
20 #include "softbus_client_frame_manager.h"
21 #include "softbus_error_code.h"
22
23 #define protected public
24 #define private public
25 #include "softbus_client_frame_manager.c"
26 #undef private
27 #undef protected
28
29 using namespace std;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 #define FRAME_HEADER_LEN 4
34
35 class SoftbusClientEventManagerTest : public testing::Test {
36 public:
SoftbusClientEventManagerTest()37 SoftbusClientEventManagerTest()
38 {}
~SoftbusClientEventManagerTest()39 ~SoftbusClientEventManagerTest()
40 {}
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
OnEventCallback(void * arg,unsigned int argLen,void * userData)43 static int OnEventCallback(void *arg, unsigned int argLen, void *userData)
44 {
45 return 0;
46 }
SetUp()47 void SetUp() override
48 {}
TearDown()49 void TearDown() override
50 {}
51 };
52
SetUpTestCase(void)53 void SoftbusClientEventManagerTest::SetUpTestCase(void)
54 {}
55
TearDownTestCase(void)56 void SoftbusClientEventManagerTest::TearDownTestCase(void)
57 {}
58
59 /**
60 * @tc.name: EventClientInit001
61 * @tc.desc: EventClientInit, use the wrong parameter.
62 * @tc.desc: EventClientDeinit, use the wrong parameter.
63 * @tc.type: FUNC
64 * @tc.require:
65 */
66 HWTEST_F(SoftbusClientEventManagerTest, EventClientInit001, TestSize.Level1)
67 {
68 EventClientDeinit();
69 int ret = EventClientInit();
70 EXPECT_EQ(SOFTBUS_OK, ret);
71
72 EventClientDeinit();
73 }
74
75 /**
76 * @tc.name: EventClientInit002
77 * @tc.desc: EventClientInit, use the wrong parameter.
78 * @tc.desc: EventClientDeinit, use the wrong parameter.
79 * @tc.type: FUNC
80 * @tc.require:
81 */
82 HWTEST_F(SoftbusClientEventManagerTest, EventClientInit002, TestSize.Level1)
83 {
84 int ret = EventClientInit();
85 EXPECT_EQ(SOFTBUS_OK, ret);
86
87 ret = EventClientInit(); // test is inited
88 EXPECT_EQ(SOFTBUS_OK, ret);
89
90 EventClientDeinit();
91 }
92
93 /**
94 * @tc.name: EventClientInit003
95 * @tc.desc: EventClientInit, use the wrong parameter.
96 * @tc.desc: EventClientDeinit, use the wrong parameter.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(SoftbusClientEventManagerTest, EventClientInit003, TestSize.Level1)
101 {
102 ASSERT_TRUE(nullptr == g_observerList);
103 g_observerList = CreateSoftBusList();
104 int ret = EventClientInit();
105 EXPECT_EQ(SOFTBUS_OK, ret);
106 EventClientDeinit();
107 }
108
109 /**
110 * @tc.name: RegisterEventCallback001
111 * @tc.desc: RegisterEventCallback, use the wrong parameter.
112 * @tc.desc: CLIENT_NotifyObserver, use the wrong parameter.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(SoftbusClientEventManagerTest, RegisterEventCallback001, TestSize.Level1)
117 {
118 EventCallback *cb =
119 (EventCallback *)SoftBusCalloc(sizeof(EventCallback));
120 ASSERT_TRUE(cb != nullptr);
121
122 std::unique_ptr<char[]> data = nullptr;
123 ssize_t len = 2;
124 data = std::make_unique<char[]>(len + FRAME_HEADER_LEN);
125
126 int res = -1;
127 int ret = RegisterEventCallback((enum SoftBusEvent)res, *cb, data.get() + FRAME_HEADER_LEN);
128 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
129 res = 4;
130 ret = RegisterEventCallback((enum SoftBusEvent)res, *cb, data.get() + FRAME_HEADER_LEN);
131 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
132 res = 1;
133 ret = RegisterEventCallback(EVENT_SERVER_DEATH, NULL, data.get() + FRAME_HEADER_LEN);
134 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
135
136
137 ret = RegisterEventCallback((enum SoftBusEvent)res, *cb, data.get() + FRAME_HEADER_LEN);
138 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
139
140 unsigned int argLen = 2;
141 CLIENT_NotifyObserver((enum SoftBusEvent)res, data.get() + FRAME_HEADER_LEN, argLen);
142
143 CLIENT_NotifyObserver(EVENT_SERVER_DEATH, data.get() + FRAME_HEADER_LEN, argLen);
144
145 enum SoftBusEvent event = SoftBusEvent::EVENT_SERVER_DEATH;
146 CLIENT_NotifyObserver(event, data.get() + FRAME_HEADER_LEN, argLen);
147
148 ret = EventClientInit();
149 EXPECT_EQ(SOFTBUS_OK, ret);
150
151 CLIENT_NotifyObserver(event, data.get() + FRAME_HEADER_LEN, argLen);
152
153 event = SoftBusEvent::EVENT_BUTT;
154 CLIENT_NotifyObserver(event, data.get() + FRAME_HEADER_LEN, argLen);
155
156 if (cb != nullptr) {
157 SoftBusFree(cb);
158 }
159 }
160
161 /**
162 * @tc.name: RegisterEventCallback002
163 * @tc.desc: RegisterEventCallback
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(SoftbusClientEventManagerTest, RegisterEventCallback002, TestSize.Level1)
168 {
169 EventCallback cb = SoftbusClientEventManagerTest::OnEventCallback;
170
171 enum SoftBusEvent event = EVENT_SERVER_RECOVERY;
172 const ssize_t len = 2;
173 std::unique_ptr<char[]> data = std::make_unique<char[]>(len + FRAME_HEADER_LEN);
174 ASSERT_TRUE(data != nullptr);
175
176 EventClientDeinit();
177 int ret = RegisterEventCallback(event, cb, data.get() + FRAME_HEADER_LEN);
178 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
179
180 ret = EventClientInit();
181 EXPECT_EQ(SOFTBUS_OK, ret);
182
183 ret = RegisterEventCallback(event, cb, data.get());
184 EXPECT_EQ(SOFTBUS_OK, ret);
185
186 unsigned int argLen = 2;
187 CLIENT_NotifyObserver(event, data.get() + FRAME_HEADER_LEN, argLen);
188 }
189
190 /**
191 * @tc.name: RegisterEventCallback003
192 * @tc.desc: RegisterEventCallback
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(SoftbusClientEventManagerTest, RegisterEventCallback003, TestSize.Level1)
197 {
198 EventCallback cb = SoftbusClientEventManagerTest::OnEventCallback;
199
200 enum SoftBusEvent event = EVENT_SERVER_RECOVERY;
201 const ssize_t len = 2;
202 std::unique_ptr<char[]> data = std::make_unique<char[]>(len + FRAME_HEADER_LEN);
203 ASSERT_TRUE(data != nullptr);
204
205 EventClientDeinit();
206 int ret = RegisterEventCallback(event, cb, data.get() + FRAME_HEADER_LEN);
207 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
208
209 ret = EventClientInit();
210 EXPECT_EQ(SOFTBUS_OK, ret);
211
212 ret = RegisterEventCallback(event, cb, data.get());
213 EXPECT_EQ(SOFTBUS_OK, ret);
214
215 g_observerList->cnt = MAX_OBSERVER_CNT;
216 ret = RegisterEventCallback(event, cb, data.get());
217 EXPECT_EQ(SOFTBUS_TRANS_OBSERVER_EXCEED_LIMIT, ret);
218 }
219
220 /**
221 * @tc.name: DelClientPkgName001
222 * @tc.desc: DelClientPkgName, use the wrong parameter.
223 * @tc.desc: EventClientDeinit, use the wrong parameter.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(SoftbusClientEventManagerTest, DelClientPkgName001, TestSize.Level1)
228 {
229 const char *pkgName = "000";
230 int32_t ret = InitSoftBus(NULL);
231 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, ret);
232
233 ret = InitSoftBus(pkgName);
234 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
235
236 char *clientName[SOFTBUS_PKGNAME_MAX_NUM] = {0};
237 uint32_t clientNameNum = GetSoftBusClientNameList(NULL, SOFTBUS_PKGNAME_MAX_NUM);
238 EXPECT_EQ(0, clientNameNum);
239 clientNameNum = GetSoftBusClientNameList(clientName, 0);
240 EXPECT_EQ(0, clientNameNum);
241
242 clientNameNum = GetSoftBusClientNameList(clientName, SOFTBUS_PKGNAME_MAX_NUM);
243 EXPECT_EQ(0, clientNameNum);
244 }
245
246 /**
247 * @tc.name: CheckPackageName001
248 * @tc.desc: CheckPackageName, use the wrong parameter.
249 * @tc.desc: EventClientDeinit, use the wrong parameter.
250 * @tc.desc: AddClientPkgName, number of pkgName exceeds maximum.
251 * @tc.desc: DelClientPkgName
252 * @tc.desc: FreeClientPkgName
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(SoftbusClientEventManagerTest, CheckPackageName001, TestSize.Level1)
257 {
258 const char *pkgName = "000";
259
260 const char *tmpPkgName = "000111";
261 int32_t ret = CheckPackageName(tmpPkgName);
262 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, ret);
263
264 FreeClientPkgName();
265 ret = AddClientPkgName(pkgName);
266 EXPECT_EQ(SOFTBUS_OK, ret);
267 ret = AddClientPkgName(pkgName);
268 EXPECT_EQ(SOFTBUS_INVALID_PKGNAME, ret);
269
270 DelClientPkgName(pkgName);
271 FreeClientPkgName();
272 }
273
274 /**
275 * @tc.name: ConnClientDeinitTest001
276 * @tc.desc: ClientModuleDeinit
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(SoftbusClientEventManagerTest, ConnClientDeinitTest001, TestSize.Level1)
281 {
282 ConnClientDeinit();
283 ClientModuleDeinit();
284 EXPECT_TRUE(1);
285 }
286 } // OHOS
287