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
16 #include <gtest/gtest.h>
17
18 #include "if_system_ability_manager.h"
19 #include "iservice_registry.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_def.h"
22 #include "trans_client_proxy_standard.h"
23 #include "trans_type.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 #define TEST_TMP_DATE 1
29 #define TEST_ERRTMP_DATE (-1)
30 #define SOFTBUS_SA_ID 4700
31
32 namespace OHOS {
33 class TransClientProxyStandardTest : public testing::Test {
34 public:
TransClientProxyStandardTest()35 TransClientProxyStandardTest() {}
~TransClientProxyStandardTest()36 ~TransClientProxyStandardTest() {}
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
SetUp()39 void SetUp() override {}
TearDown()40 void TearDown() override {}
41 };
42
SetUpTestCase(void)43 void TransClientProxyStandardTest::SetUpTestCase(void) {}
TearDownTestCase(void)44 void TransClientProxyStandardTest::TearDownTestCase(void) {}
45
46 /**
47 * @tc.name: InformPermissionChangeTest001
48 * @tc.desc: trans client proxy standard test, use the normal parameter.
49 * @tc.type: FUNC
50 * @tc.require:
51 */
52 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest001, TestSize.Level1)
53 {
54 #define TEST_INVALID 0
55
56 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
57 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
58 ASSERT_TRUE(remoteObject != nullptr);
59 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
60 ASSERT_TRUE(clientProxy != nullptr);
61
62 int32_t tmp = TEST_INVALID;
63
64 void *addr = nullptr;
65 uint32_t addrTypeLen = TEST_INVALID;
66 void *metaInfo = nullptr;
67 uint32_t infoLen = TEST_INVALID;
68 const char *networkId = nullptr;
69 int32_t ret = clientProxy->OnJoinLNNResult(addr, addrTypeLen, networkId, tmp);
70 EXPECT_EQ(SOFTBUS_OK, ret);
71
72 ret = clientProxy->OnJoinMetaNodeResult(addr, addrTypeLen, metaInfo, infoLen, tmp);
73 EXPECT_EQ(SOFTBUS_OK, ret);
74
75 ret = clientProxy->OnLeaveLNNResult(networkId, tmp);
76 EXPECT_EQ(SOFTBUS_OK, ret);
77
78 ret = clientProxy->OnLeaveMetaNodeResult(networkId, tmp);
79 EXPECT_EQ(SOFTBUS_OK, ret);
80
81 bool isOnline = false;
82 ret = clientProxy->OnNodeOnlineStateChanged("test", isOnline, addr, addrTypeLen);
83 EXPECT_EQ(SOFTBUS_OK, ret);
84
85 ret = clientProxy->OnNodeBasicInfoChanged("test", addr, addrTypeLen, tmp);
86 EXPECT_EQ(SOFTBUS_OK, ret);
87
88 ret = clientProxy->OnTimeSyncResult(addr, addrTypeLen, tmp);
89 EXPECT_EQ(SOFTBUS_OK, ret);
90
91 clientProxy->OnPublishLNNResult(tmp, tmp);
92
93 clientProxy->OnRefreshLNNResult(tmp, tmp);
94
95 clientProxy->OnRefreshDeviceFound(addr, addrTypeLen);
96 }
97
98 /**
99 * @tc.name: InformPermissionChangeTest002
100 * @tc.desc: trans client proxy standard test, use the normal parameter.
101 * @tc.type: FUNC
102 * @tc.require:
103 */
104 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest002, TestSize.Level1)
105 {
106 const char *pkgName = "dms";
107 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
108 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
109 ASSERT_TRUE(remoteObject != nullptr);
110 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
111 ASSERT_TRUE(clientProxy != nullptr);
112
113 int32_t ret = clientProxy->OnChannelLinkDown(nullptr, TEST_TMP_DATE);
114 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
115
116 ret = clientProxy->OnClientPermissonChange(nullptr, TEST_TMP_DATE);
117 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
118
119 ret = clientProxy->OnClientPermissonChange(pkgName, TEST_ERRTMP_DATE);
120 EXPECT_EQ(SOFTBUS_OK, ret);
121 }
122
123 /**
124 * @tc.name: OnCheckCollabRelation001
125 * @tc.desc: trans client proxy standard test, use the normal parameter.
126 * @tc.type: FUNC
127 * @tc.require:
128 */
129 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest003, TestSize.Level1)
130 {
131 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
132 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
133 ASSERT_TRUE(remoteObject != nullptr);
134 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
135 ASSERT_TRUE(clientProxy != nullptr);
136
137 int32_t ret = clientProxy->OnCheckCollabRelation(nullptr, false, nullptr, 1, 1);
138 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
139
140 CollabInfo sourceInfo = {};
141 CollabInfo sinkInfo = {};
142
143 ret = clientProxy->OnCheckCollabRelation(&sourceInfo, false, nullptr, 1, 1);
144 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
145
146 ret = clientProxy->OnCheckCollabRelation(&sourceInfo, false, &sinkInfo, 1, 1);
147 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, ret);
148 }
149
150 /**
151 * @tc.name: OnChannelOpened001
152 * @tc.desc: trans client proxy standard test, use the normal parameter.
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest004, TestSize.Level1)
157 {
158 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
159 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
160 ASSERT_TRUE(remoteObject != nullptr);
161 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
162 ASSERT_TRUE(clientProxy != nullptr);
163
164 ChannelInfo channel = {0};
165 const char *sessionName = "testSessionName";
166 int32_t ret = clientProxy->OnChannelOpened(nullptr, nullptr);
167 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
168
169 ret = clientProxy->OnChannelOpened(sessionName, nullptr);
170 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
171
172 ret = clientProxy->OnChannelOpened(sessionName, &channel);
173 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
174 channel.isServer = true;
175 ret = clientProxy->OnChannelOpened(sessionName, &channel);
176 EXPECT_EQ(SOFTBUS_IPC_ERR, ret);
177 }
178
179 /**
180 * @tc.name: SetChannelInfo001
181 * @tc.desc: trans client proxy standard test, use the normal parameter.
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest005, TestSize.Level1)
186 {
187 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
188 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
189 ASSERT_TRUE(remoteObject != nullptr);
190 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
191 ASSERT_TRUE(clientProxy != nullptr);
192
193 const char *sessionName = "testSessionName";
194 int32_t ret = clientProxy->SetChannelInfo(sessionName, 1, 1, 1);
195 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED, ret);
196
197 ret = clientProxy->SetChannelInfo(nullptr, 1, 1, 1);
198 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
199 }
200
201 /**
202 * @tc.name: OnClientChannelOnQos001
203 * @tc.desc: OnClientChannelOnQos test
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest006, TestSize.Level1)
208 {
209 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
210 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
211 ASSERT_TRUE(remoteObject != nullptr);
212 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
213 ASSERT_TRUE(clientProxy != nullptr);
214
215 int32_t channelId = 1;
216 int32_t channelType = 1;
217 QoSEvent event = QOS_SATISFIED;
218 const QosTV *qos = nullptr;
219 uint32_t count = 1;
220
221 int32_t ret = clientProxy->OnClientChannelOnQos(channelId, channelType, event, qos, count);
222 EXPECT_NE(SOFTBUS_OK, ret);
223 }
224
225 /**
226 * @tc.name: OnBrProxyOpenedQos001
227 * @tc.desc: OnBrProxyOpened test
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest007, TestSize.Level1)
232 {
233 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
234 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
235 ASSERT_TRUE(remoteObject != nullptr);
236 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
237 ASSERT_TRUE(clientProxy != nullptr);
238
239 int32_t channelId = 1;
240 int32_t reason = 1;
241
242 int32_t ret = clientProxy->OnBrProxyOpened(channelId, nullptr, nullptr, reason);
243 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
244
245 const char *brMac = "11:22:33"; // test value
246 const char *uuid = "111111"; // test value
247 ret = clientProxy->OnBrProxyOpened(channelId, brMac, uuid, reason);
248 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
249 }
250
251 /**
252 * @tc.name: OnBrProxyDataRecv001
253 * @tc.desc: OnBrProxyDataRecv test
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest008, TestSize.Level1)
258 {
259 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
260 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
261 ASSERT_TRUE(remoteObject != nullptr);
262 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
263 ASSERT_TRUE(clientProxy != nullptr);
264
265 int32_t channelId = 1;
266 int32_t len = 1;
267
268 int32_t ret = clientProxy->OnBrProxyDataRecv(channelId, nullptr, len);
269 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
270
271 uint8_t data = 1;
272 ret = clientProxy->OnBrProxyDataRecv(channelId, &data, len);
273 EXPECT_NE(SOFTBUS_INVALID_PARAM, ret);
274 }
275
276 /**
277 * @tc.name: OnBrProxyStateChanged001
278 * @tc.desc: OnBrProxyStateChanged test
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest009, TestSize.Level1)
283 {
284 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
285 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
286 ASSERT_TRUE(remoteObject != nullptr);
287 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
288 ASSERT_TRUE(clientProxy != nullptr);
289
290 int32_t channelId = 1;
291 int32_t channelState = 1;
292
293 int32_t ret = clientProxy->OnBrProxyStateChanged(channelId, channelState);
294 EXPECT_NE(SOFTBUS_OK, ret);
295 }
296
297 /**
298 * @tc.name: OnBrProxyQueryPermission001
299 * @tc.desc: OnBrProxyQueryPermission test
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(TransClientProxyStandardTest, TransClientProxyStandardTest010, TestSize.Level1)
304 {
305 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
306 sptr<IRemoteObject> remoteObject = saManager->GetSystemAbility(SOFTBUS_SA_ID);
307 ASSERT_TRUE(remoteObject != nullptr);
308 sptr<TransClientProxy> clientProxy = new (std::nothrow) TransClientProxy(remoteObject);
309 ASSERT_TRUE(clientProxy != nullptr);
310
311 const char *bundleName = "testName";
312 bool isEmpowered = true;
313
314 int32_t ret = clientProxy->OnBrProxyQueryPermission(bundleName, &isEmpowered);
315 EXPECT_NE(SOFTBUS_OK, ret);
316
317 clientProxy->OnDataLevelChanged(nullptr, nullptr);
318 clientProxy->OnMsdpRangeResult(nullptr);
319 }
320 } // namespace OHOS