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#include <gmock/gmock.h>
16#include <gtest/gtest.h>
17#include "bluetooth_pbap_client.h"
18#include "bluetooth_host.h"
19
20using namespace testing;
21using namespace testing::ext;
22using namespace std;
23
24namespace OHOS {
25namespace Bluetooth {
26constexpr int TIME = 2;
27
28class PbapClientObserverCommon : public PbapClientObserver {
29public:
30    PbapClientObserverCommon() = default;
31    virtual ~PbapClientObserverCommon() = default;
32
33    void OnServiceConnectionStateChanged(const BluetoothRemoteDevice &device, int state) {}
34    void OnServicePasswordRequired(const BluetoothRemoteDevice &device,
35        const std::vector<uint8_t> &description, uint8_t charset, bool fullAccess = true) {}
36    void OnActionCompleted(
37        const BluetoothRemoteDevice &device, int respCode, int actionType, const PbapPhoneBookData &result) {}
38
39private:
40};
41
42static PbapClientObserverCommon observer_;
43static PbapClient *profile_;
44
45
46class PbapClientTest : public testing::Test {
47public:
48    PbapClientTest()
49    {}
50    ~PbapClientTest()
51    {}
52    static void SetUpTestCase(void);
53    static void TearDownTestCase(void);
54    void SetUp();
55    void TearDown();
56    BluetoothHost *host_;
57};
58
59
60void PbapClientTest::SetUpTestCase(void) {}
61void PbapClientTest::TearDownTestCase(void) {}
62
63void PbapClientTest::SetUp()
64{
65    host_ = &BluetoothHost::GetDefaultHost();
66    host_->EnableBt();
67    host_->EnableBle();
68    sleep(TIME);
69}
70
71void PbapClientTest::TearDown()
72{
73    host_->DisableBt();
74    host_->DisableBle();
75    host_ = nullptr;
76    sleep(TIME);
77}
78
79/*
80 * @tc.number: PbapClientUnit001
81 * @tc.name: Connect
82 * @tc.desc: Initiate the establishment of a service level connection to remote pbapclient device.
83*/
84HWTEST_F(PbapClientTest, PbapClient_UnitTest_Connect, TestSize.Level1)
85{
86    GTEST_LOG_(INFO) << "PbapClient_UnitTest_Connect start";
87
88    profile_ = PbapClient::GetProfile();
89    BluetoothRemoteDevice device;
90    bool isOK = profile_->Connect(device);
91    EXPECT_EQ(isOK, true);
92    GTEST_LOG_(INFO) << "PbapClient_UnitTest_Connect end";
93}
94
95/*
96 * @tc.number: PbapClientUnit002
97 * @tc.name: Disconnect
98 * @tc.desc: Release the connection from pbapclient device.
99*/
100HWTEST_F(PbapClientTest, PbapClient_UnitTest_Disconnect, TestSize.Level1)
101{
102    GTEST_LOG_(INFO) << "PbapClient_UnitTest_Disconnect start";
103
104    profile_ = PbapClient::GetProfile();
105    BluetoothRemoteDevice device;
106    bool isOK = profile_->Disconnect(device);
107    EXPECT_EQ(isOK, true);
108    GTEST_LOG_(INFO) << "PbapClient_UnitTest_Disconnect end";
109}
110
111/*
112 * @tc.number: PbapClientUnit003
113 * @tc.name: RegisterObserver
114 * @tc.desc: Register PbapClient observer instance.
115*/
116HWTEST_F(PbapClientTest, PbapClient_UnitTest_RegisterObserver, TestSize.Level1)
117{
118    GTEST_LOG_(INFO) << "PbapClient_UnitTest_RegisterObserver start";
119
120    profile_ = PbapClient::GetProfile();
121    profile_->RegisterObserver(&observer_);
122    GTEST_LOG_(INFO) << "PbapClient_UnitTest_RegisterObserver end";
123}
124
125/*
126 * @tc.number: PbapClientUnit004
127 * @tc.name: DeregisterObserver
128 * @tc.desc: Deregister PbapClient observer instance.
129*/
130HWTEST_F(PbapClientTest, PbapClient_UnitTest_DeregisterObserver, TestSize.Level1)
131{
132    GTEST_LOG_(INFO) << "PbapClient_UnitTest_DeregisterObserver start";
133
134    profile_ = PbapClient::GetProfile();
135    profile_->DeregisterObserver(&observer_);
136    GTEST_LOG_(INFO) << "PbapClient_UnitTest_DeregisterObserver end";
137}
138
139/*
140 * @tc.number: PbapClientUnit005
141 * @tc.name: GetConnectedDevices
142 * @tc.desc: Get remote PbapClient device list which are in the connected state.
143*/
144HWTEST_F(PbapClientTest, PbapClient_UnitTest_GetConnectedDevices, TestSize.Level1)
145{
146    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetConnectedDevices start";
147    profile_ = PbapClient::GetProfile();
148    vector<BluetoothRemoteDevice> devices = profile_->GetConnectedDevices();
149    int vectorSize = devices.size();
150    EXPECT_EQ(vectorSize, 0);
151    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetConnectedDevices end";
152}
153
154/*
155 * @tc.number: PbapClientUnit006
156 * @tc.name: GetDevicesByStates
157 * @tc.desc: Get remote PbapClient device list which are in the specified states.
158*/
159HWTEST_F(PbapClientTest, PbapClient_UnitTest_GetDevicesByStates, TestSize.Level1)
160{
161    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetDevicesByStates start";
162    profile_ = PbapClient::GetProfile();
163    vector<int> states = {static_cast<int>(BTConnectState::CONNECTED)};
164    vector<BluetoothRemoteDevice> devices = profile_->GetDevicesByStates(states);
165    int vectorSize = devices.size();
166    EXPECT_EQ(vectorSize, 0);
167    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetDevicesByStates end";
168}
169
170/*
171 * @tc.number: PbapClientUnit007
172 * @tc.name: GetDeviceState
173 * @tc.desc: Get remote PbapClient device state which are in the specified states.
174*/
175HWTEST_F(PbapClientTest, PbapClient_UnitTest_GetDeviceState, TestSize.Level1)
176{
177    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetDeviceState start";
178
179    profile_ = PbapClient::GetProfile();
180    BluetoothRemoteDevice device;
181    int state = profile_->GetDeviceState(device);
182    EXPECT_EQ(state, -1);
183    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetDevicesByStates end";
184}
185
186/*
187 * @tc.number: PbapClientUnit008
188 * @tc.name: SetConnectionStrategy
189 * @tc.desc: set the strategy with the specified remote device
190*/
191HWTEST_F(PbapClientTest, PbapClient_UnitTest_SetConnectionStrategy, TestSize.Level1)
192{
193    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetConnectionStrategy start";
194    profile_ = PbapClient::GetProfile();
195    BluetoothRemoteDevice device;
196    int strategy = 0;
197    bool isOk = profile_->SetConnectionStrategy(device, strategy);
198    EXPECT_EQ(isOk, false);
199    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetConnectionStrategy end";
200}
201
202/*
203 * @tc.number: PbapClientUnit009
204 * @tc.name: GetConnectionStrategy
205 * @tc.desc: get the strategy with the specified remote device
206*/
207HWTEST_F(PbapClientTest, PbapClient_UnitTest_GetConnectionStrategy, TestSize.Level1)
208{
209    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetConnectionStrategy start";
210    profile_ = PbapClient::GetProfile();
211    BluetoothRemoteDevice device;
212    int state = profile_->GetConnectionStrategy(device);
213    EXPECT_EQ(state, -1);
214    GTEST_LOG_(INFO) << "PbapClient_UnitTest_GetConnectionStrategy end";
215}
216
217/*
218 * @tc.number: PbapClientUnit010
219 * @tc.name: SetDevicePassword
220 * @tc.desc: Set device's password. please call after OnServicePasswordRequired event.
221*/
222HWTEST_F(PbapClientTest, PbapClient_UnitTest_SetDevicePassword, TestSize.Level1)
223{
224    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetDevicePassword start";
225    profile_ = PbapClient::GetProfile();
226    BluetoothRemoteDevice device;
227    string password = "123";
228    string userId = "123";
229    int state = profile_->SetDevicePassword(device, password, userId);
230    EXPECT_EQ(state, -1);
231    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetDevicePassword end";
232}
233
234/*
235 * @tc.number: PbapClientUnit011
236 * @tc.name: PullPhoneBook
237 * @tc.desc: Pull phone book from remote device after connected.
238*/
239HWTEST_F(PbapClientTest, PbapClient_UnitTest_PullPhoneBook, TestSize.Level1)
240{
241    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullPhoneBook start";
242    profile_ = PbapClient::GetProfile();
243    BluetoothRemoteDevice device;
244    PbapPullPhoneBookParam param;
245    int state = profile_->PullPhoneBook(device, param);
246    EXPECT_EQ(state, -1);
247    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullPhoneBook end";
248}
249
250/*
251 * @tc.number: PbapClientUnit012
252 * @tc.name: SetPhoneBook
253 * @tc.desc: Set phone book from remote device after connected.
254*/
255HWTEST_F(PbapClientTest, PbapClient_UnitTest_SetPhoneBook, TestSize.Level1)
256{
257    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetPhoneBook start";
258    profile_ = PbapClient::GetProfile();
259    BluetoothRemoteDevice device;
260    std::u16string name = {'a', 'b', 'c', 0};
261    int flag = 0;
262    int state = profile_->SetPhoneBook(device, name, flag);
263    EXPECT_EQ(state, -1);
264    GTEST_LOG_(INFO) << "PbapClient_UnitTest_SetPhoneBook end";
265}
266
267/*
268 * @tc.number: PbapClientUnit013
269 * @tc.name: PullvCardListing
270 * @tc.desc: Pull vCard listing from remote device after connected.
271*/
272HWTEST_F(PbapClientTest, PbapClient_UnitTest_PullvCardListing, TestSize.Level1)
273{
274    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullvCardListing start";
275    profile_ = PbapClient::GetProfile();
276    BluetoothRemoteDevice device;
277    PbapPullvCardListingParam param;
278    int state = profile_->PullvCardListing(device, param);
279    EXPECT_EQ(state, -1);
280    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullvCardListing end";
281}
282
283/*
284 * @tc.number: PbapClientUnit014
285 * @tc.name: PullvCardEntry
286 * @tc.desc: Pull vCard entry from remote device after connected.
287*/
288HWTEST_F(PbapClientTest, PbapClient_UnitTest_PullvCardEntry, TestSize.Level1)
289{
290    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullvCardEntry start";
291    profile_ = PbapClient::GetProfile();
292    BluetoothRemoteDevice device;
293    PbapPullvCardEntryParam param;
294    int state = profile_->PullvCardEntry(device, param);
295    EXPECT_EQ(state, -1);
296    GTEST_LOG_(INFO) << "PbapClient_UnitTest_PullvCardEntry end";
297}
298
299/*
300 * @tc.number: PbapClientUnit015
301 * @tc.name: IsDownloading
302 * @tc.desc: Check if local device is downloading phonebook from remote device.
303*/
304HWTEST_F(PbapClientTest, PbapClient_UnitTest_IsDownloading, TestSize.Level1)
305{
306    GTEST_LOG_(INFO) << "PbapClient_UnitTest_IsDownloading start";
307    profile_ = PbapClient::GetProfile();
308    BluetoothRemoteDevice device;
309    bool isOk = profile_->IsDownloading(device);
310    EXPECT_EQ(isOk, false);
311    GTEST_LOG_(INFO) << "PbapClient_UnitTest_IsDownloading end";
312}
313
314/*
315 * @tc.number: PbapClientUnit015
316 * @tc.name: AbortDownloading
317 * @tc.desc: Abort downloading phonebook from remote device.
318*/
319HWTEST_F(PbapClientTest, PbapClient_UnitTest_AbortDownloading, TestSize.Level1)
320{
321    GTEST_LOG_(INFO) << "PbapClient_UnitTest_AbortDownloading start";
322    profile_ = PbapClient::GetProfile();
323    BluetoothRemoteDevice device;
324    int state = profile_->AbortDownloading(device);
325    EXPECT_EQ(state, -1);
326    GTEST_LOG_(INFO) << "PbapClient_UnitTest_AbortDownloading end";
327}
328}  // namespace Bluetooth
329}  // namespace OHOS