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
26using namespace testing;
27using namespace testing::ext;
28namespace OHOS {
29namespace Bluetooth {
30class GattClientCallbackTest : public GattClientCallback {
31public:
32    GattClientCallbackTest()
33    {}
34    ~GattClientCallbackTest()
35    {}
36
37    void OnConnectionStateChanged(int connectionState, int ret)
38    {
39        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnConnectionStateChanged called";
40    }
41
42    void OnCharacteristicChanged(const GattCharacteristic &characteristic)
43    {
44        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicChanged called";
45    }
46
47    void OnCharacteristicReadResult(const GattCharacteristic &characteristic, int ret)
48    {
49        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicReadResult called";
50    }
51
52    void OnCharacteristicWriteResult(const GattCharacteristic &characteristic, int ret)
53    {
54        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnCharacteristicWriteResult called";
55    }
56
57    void OnDescriptorReadResult(const GattDescriptor &descriptor, int ret)
58    {
59        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnDescriptorReadResult called";
60    }
61
62    void OnDescriptorWriteResult(const GattDescriptor &descriptor, int ret)
63    {
64        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnDescriptorWriteResult called";
65    }
66
67    void OnMtuUpdate(int mtu, int ret)
68    {
69        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnMtuUpdate called";
70    }
71
72    void OnServicesDiscovered(int status)
73    {
74        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnServicesDiscovered called";
75    }
76
77    void OnConnectionParameterChanged(int interval, int latency, int timeout, int status)
78    {
79        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnConnectionParameterChanged called";
80    }
81
82    void OnSetNotifyCharacteristic(int status)
83    {
84        GTEST_LOG_(INFO) << "GattClientCallbackTest::OnSetNotifyCharacteristic called";
85    }
86};
87
88class GattClientTest : public testing::Test {
89public:
90    GattClientTest()
91    {}
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
102void GattClientTest::SetUpTestCase(void)
103{}
104void GattClientTest::TearDownTestCase(void)
105{}
106void GattClientTest::SetUp()
107{
108    tempData_ = 0;
109}
110
111void GattClientTest::TearDown()
112{}
113
114/*
115 * @tc.number: GattClient001
116 * @tc.name: GattClient
117*/
118HWTEST_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*/
130HWTEST_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*/
147HWTEST_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*/
165HWTEST_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*/
183HWTEST_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*/
206HWTEST_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*/
223HWTEST_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*/
245HWTEST_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*/
266HWTEST_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*/
285HWTEST_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*/
308HWTEST_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*/
330HWTEST_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*/
351HWTEST_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