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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "bluetooth_errorcode.h"
20 #include "bluetooth_gatt_client.h"
21 #include "bluetooth_gatt_descriptor.h"
22 #include "bluetooth_host.h"
23 #include "uuid.h"
24 #include "vector"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 namespace OHOS {
29 namespace Bluetooth {
30 class GattClientCallbackTest : public GattClientCallback {
31 public:
GattClientCallbackTest()32     GattClientCallbackTest()
33     {}
~GattClientCallbackTest()34     ~GattClientCallbackTest()
35     {}
36 
OnConnectionStateChanged(int connectionState,int ret)37     void OnConnectionStateChanged(int connectionState, int ret)
38     {
39         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnConnectionStateChanged called";
40     }
41 
OnCharacteristicChanged(const GattCharacteristic & characteristic)42     void OnCharacteristicChanged(const GattCharacteristic &characteristic)
43     {
44         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicChanged called";
45     }
46 
OnCharacteristicReadResult(const GattCharacteristic & characteristic,int ret)47     void OnCharacteristicReadResult(const GattCharacteristic &characteristic, int ret)
48     {
49         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicReadResult called";
50     }
51 
OnCharacteristicWriteResult(const GattCharacteristic & characteristic,int ret)52     void OnCharacteristicWriteResult(const GattCharacteristic &characteristic, int ret)
53     {
54         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicWriteResult called";
55     }
56 
OnDescriptorReadResult(const GattDescriptor & descriptor,int ret)57     void OnDescriptorReadResult(const GattDescriptor &descriptor, int ret)
58     {
59         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnDescriptorReadResult called";
60     }
61 
OnDescriptorWriteResult(const GattDescriptor & descriptor,int ret)62     void OnDescriptorWriteResult(const GattDescriptor &descriptor, int ret)
63     {
64         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnDescriptorWriteResult called";
65     }
66 
OnMtuUpdate(int mtu,int ret)67     void OnMtuUpdate(int mtu, int ret)
68     {
69         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnMtuUpdate called";
70     }
71 
OnServicesDiscovered(int status)72     void OnServicesDiscovered(int status)
73     {
74         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnServicesDiscovered called";
75     }
76 
OnConnectionParameterChanged(int interval,int latency,int timeout,int status)77     void OnConnectionParameterChanged(int interval, int latency, int timeout, int status)
78     {
79         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnConnectionParameterChanged called";
80     }
81 
OnSetNotifyCharacteristic(int status)82     void OnSetNotifyCharacteristic(int status)
83     {
84         GTEST_LOG_(INFO) << "GattClientCallbackTest::OnSetNotifyCharacteristic called";
85     }
86 };
87 
88 class GattClientTest : public testing::Test {
89 public:
GattClientTest()90     GattClientTest()
91     {}
~GattClientTest()92     ~GattClientTest()
93     {}
94 
95     int tempData_ = 0;
96     static void SetUpTestCase(void);
97     static void TearDownTestCase(void);
98     void SetUp();
99     void TearDown();
100 };
101 
SetUpTestCase(void)102 void GattClientTest::SetUpTestCase(void)
103 {}
TearDownTestCase(void)104 void GattClientTest::TearDownTestCase(void)
105 {}
SetUp()106 void GattClientTest::SetUp()
107 {
108     tempData_ = 0;
109 }
110 
TearDown()111 void GattClientTest::TearDown()
112 {}
113 
114 /*
115  * @tc.number: GattClient001
116  * @tc.name: GattClient
117 */
118 HWTEST_F(GattClientTest, GattClient_UnitTest_GattClient, TestSize.Level1)
119 {
120     GTEST_LOG_(INFO) << "GattClient_UnitTest_GattClient start";
121     BluetoothRemoteDevice device;
122     GattClient client(device);
123     GTEST_LOG_(INFO) << "GattClient_UnitTest_GattClient end";
124 }
125 
126 /*
127  * @tc.number: GattClient002
128  * @tc.name: Connect
129 */
130 HWTEST_F(GattClientTest, GattClient_UnitTest_Connect, TestSize.Level1)
131 {
132     GTEST_LOG_(INFO) << "GattClient_UnitTest_Connect start";
133     BluetoothRemoteDevice device;
134     GattClient client(device);
135     GattClientCallbackTest callback_;
136     bool isAutoConnect = true;
137     int transport = 1;
138     int result = client.Connect(callback_, isAutoConnect, transport);
139     EXPECT_NE(result, NO_ERROR);
140     GTEST_LOG_(INFO) << "GattClient_UnitTest_Connect end";
141 }
142 
143 /*
144  * @tc.number: GattClient003
145  * @tc.name: Disconnect
146 */
147 HWTEST_F(GattClientTest, GattClient_UnitTest_Disconnect, TestSize.Level1)
148 {
149     GTEST_LOG_(INFO) << "GattClient_UnitTest_Disconnect start";
150     BluetoothRemoteDevice device;
151     GattClient client(device);
152     GattClientCallbackTest callback_;
153     bool isAutoConnect = true;
154     int transport = 1;
155     client.Connect(callback_, isAutoConnect, transport);
156     int result = client.Disconnect();
157     EXPECT_NE(result, NO_ERROR);
158     GTEST_LOG_(INFO) << "GattClient_UnitTest_Disconnect end";
159 }
160 
161 /*
162  * @tc.number: GattClient004
163  * @tc.name: DiscoverServices
164 */
165 HWTEST_F(GattClientTest, GattClient_UnitTest_DiscoverServices, TestSize.Level1)
166 {
167     GTEST_LOG_(INFO) << "GattClient_UnitTest_DiscoverServices start";
168     BluetoothRemoteDevice device;
169     GattClient client(device);
170     GattClientCallbackTest callback_;
171     bool isAutoConnect = true;
172     int transport = 1;
173     client.Connect(callback_, isAutoConnect, transport);
174     int result = client.DiscoverServices();
175     EXPECT_NE(result, NO_ERROR);
176     GTEST_LOG_(INFO) << "GattClient_UnitTest_DiscoverServices end";
177 }
178 
179 /*
180  * @tc.number: GattClient005
181  * @tc.name: GetService_1
182 */
183 HWTEST_F(GattClientTest, GattClient_UnitTest_GetService_1, TestSize.Level1)
184 {
185     GTEST_LOG_(INFO) << "GattClient_UnitTest_GetService_1 start";
186     BluetoothRemoteDevice device;
187     GattClient client(device);
188     GattClientCallbackTest callback_;
189     bool isAutoConnect = true;
190     int transport = 1;
191     bool ret = false;
192     client.Connect(callback_, isAutoConnect, transport);
193     UUID id = UUID::RandomUUID();
194     client.GetService(id);
195     if (client.GetService(id) != std::nullopt) {
196         ret = true;
197     }
198     EXPECT_EQ(ret, false);
199     GTEST_LOG_(INFO) << "GattClient_UnitTest_GetService_1 end";
200 }
201 
202 /*
203  * @tc.number: GattClient006
204  * @tc.name: GetService_2
205 */
206 HWTEST_F(GattClientTest, GattClient_UnitTest_GetService_2, TestSize.Level1)
207 {
208     GTEST_LOG_(INFO) << "GattClient_UnitTest_GetService_2 start";
209     BluetoothRemoteDevice device;
210     GattClient client(device);
211     GattClientCallbackTest callback_;
212     bool isAutoConnect = true;
213     int transport = 1;
214     client.Connect(callback_, isAutoConnect, transport);
215     EXPECT_EQ((int)client.GetService().size(), 0);
216     GTEST_LOG_(INFO) << "GattClient_UnitTest_GetService_2 end";
217 }
218 
219 /*
220  * @tc.number: GattClient007
221  * @tc.name: ReadCharacteristic
222 */
223 HWTEST_F(GattClientTest, GattClient_UnitTest_ReadCharacteristic, TestSize.Level1)
224 {
225     GTEST_LOG_(INFO) << "GattClient_UnitTest_ReadCharacteristic start";
226     BluetoothRemoteDevice device;
227     GattClient client(device);
228     GattClientCallbackTest callback_;
229     bool isAutoConnect = true;
230     int transport = 1;
231     client.Connect(callback_, isAutoConnect, transport);
232     UUID uuid_ = UUID::RandomUUID();
233     int permissions = 17;
234     int properties = 37;
235     GattCharacteristic characteristic = GattCharacteristic(uuid_, permissions, properties);
236     int result = client.ReadCharacteristic(characteristic);
237     EXPECT_NE(result, NO_ERROR);
238     GTEST_LOG_(INFO) << "GattClient_UnitTest_ReadCharacteristic end";
239 }
240 
241 /*
242  * @tc.number: GattClient008
243  * @tc.name: ReadDescriptor
244 */
245 HWTEST_F(GattClientTest, GattClient_UnitTest_ReadDescriptor, TestSize.Level1)
246 {
247     GTEST_LOG_(INFO) << "GattClient_UnitTest_ReadDescriptor start";
248     BluetoothRemoteDevice device;
249     GattClient client(device);
250     GattClientCallbackTest callback_;
251     bool isAutoConnect = true;
252     int transport = 1;
253     client.Connect(callback_, isAutoConnect, transport);
254     UUID uuid_ = UUID::RandomUUID();
255     int permissions = 17;
256     GattDescriptor descriptor = GattDescriptor(uuid_, permissions);
257     int result = client.ReadDescriptor(descriptor);
258     EXPECT_NE(result, NO_ERROR);
259     GTEST_LOG_(INFO) << "GattClient_UnitTest_ReadDescriptor end";
260 }
261 
262 /*
263  * @tc.number: GattClient009
264  * @tc.name: RequestBleMtuSize
265 */
266 HWTEST_F(GattClientTest, GattClient_UnitTest_RequestBleMtuSize, TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "GattClient_UnitTest_RequestBleMtuSize start";
269     BluetoothRemoteDevice device;
270     GattClient client(device);
271     GattClientCallbackTest callback_;
272     bool isAutoConnect = true;
273     int transport = 1;
274     int result = client.Connect(callback_, isAutoConnect, transport);
275     int mtu = 17;
276     result = client.RequestBleMtuSize(mtu);
277     EXPECT_NE(result, NO_ERROR);
278     GTEST_LOG_(INFO) << "GattClient_UnitTest_RequestBleMtuSize end";
279 }
280 
281 /*
282  * @tc.number: GattClient010
283  * @tc.name: SetNotifyCharacteristic
284 */
285 HWTEST_F(GattClientTest, GattClient_UnitTest_SetNotifyCharacteristic, TestSize.Level1)
286 {
287     GTEST_LOG_(INFO) << "GattClient_UnitTest_SetNotifyCharacteristic start";
288     BluetoothRemoteDevice device;
289     GattClient client(device);
290     GattClientCallbackTest callback_;
291     bool isAutoConnect = true;
292     int transport = 1;
293     client.Connect(callback_, isAutoConnect, transport);
294     UUID uuid_ = UUID::RandomUUID();
295     int permissions = 17;
296     int properties = 37;
297     GattCharacteristic characteristic = GattCharacteristic(uuid_, permissions, properties);
298     bool enable = true;
299     int result = client.SetNotifyCharacteristic(characteristic, enable);
300     EXPECT_NE(result, NO_ERROR);
301     GTEST_LOG_(INFO) << "GattClient_UnitTest_SetNotifyCharacteristic end";
302 }
303 
304 /*
305  * @tc.number: GattClient011
306  * @tc.name: WriteCharacteristic
307 */
308 HWTEST_F(GattClientTest, GattClient_UnitTest_WriteCharacteristic, TestSize.Level1)
309 {
310     GTEST_LOG_(INFO) << "GattClient_UnitTest_WriteCharacteristic start";
311     BluetoothRemoteDevice device;
312     GattClient client(device);
313     GattClientCallbackTest callback_;
314     bool isAutoConnect = true;
315     int transport = 1;
316     client.Connect(callback_, isAutoConnect, transport);
317     UUID uuid_ = UUID::RandomUUID();
318     int permissions = 17;
319     int properties = 37;
320     GattCharacteristic characteristic = GattCharacteristic(uuid_, permissions, properties);
321     int result = client.WriteCharacteristic(characteristic);
322     EXPECT_NE(result, NO_ERROR);
323     GTEST_LOG_(INFO) << "GattClient_UnitTest_WriteCharacteristic end";
324 }
325 
326 /*
327  * @tc.number: GattClient012
328  * @tc.name: WriteDescriptor
329 */
330 HWTEST_F(GattClientTest, GattClient_UnitTest_WriteDescriptor, TestSize.Level1)
331 {
332     GTEST_LOG_(INFO) << "GattClient_UnitTest_WriteDescriptor start";
333     BluetoothRemoteDevice device;
334     GattClient client(device);
335     GattClientCallbackTest callback_;
336     bool isAutoConnect = true;
337     int transport = 1;
338     client.Connect(callback_, isAutoConnect, transport);
339     UUID uuid_ = UUID::RandomUUID();
340     int permissions = 17;
341     GattDescriptor descriptor = GattDescriptor(uuid_, permissions);
342     int result = client.WriteDescriptor(descriptor);
343     EXPECT_NE(result, NO_ERROR);
344     GTEST_LOG_(INFO) << "GattClient_UnitTest_WriteDescriptor end";
345 }
346 
347 /*
348  * @tc.number: GattClient013
349  * @tc.name: RequestConnectionPriority
350 */
351 HWTEST_F(GattClientTest, GattClient_UnitTest_RequestConnectionPriority, TestSize.Level1)
352 {
353     GTEST_LOG_(INFO) << "GattClient_UnitTest_RequestConnectionPriority start";
354     BluetoothRemoteDevice device;
355     GattClient client(device);
356     GattClientCallbackTest callback_;
357     bool isAutoConnect = true;
358     int transport = 1;
359     client.Connect(callback_, isAutoConnect, transport);
360     int connPriority = 2;
361     int result = client.RequestConnectionPriority(connPriority);
362     EXPECT_NE(result, NO_ERROR);
363     GTEST_LOG_(INFO) << "GattClient_UnitTest_RequestConnectionPriority end";
364 }
365 
366 }  // namespace Bluetooth
367 }  // namespace OHOS
368