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 "ble_test.h"
17 #include "bluetooth_def.h"
18 #include "bluetooth_errorcode.h"
19 #include <thread>
20 #include <mutex>
21 #include <condition_variable>
22 
23 namespace OHOS {
24 namespace Bluetooth {
25 BleTest *BleTest::bleInstance_ = nullptr;
26 namespace {
27 const static int defaultInt = 150;
28 const static int INTERVAL = 350;
29 const static int MIN_ADV_LENGTH = 31;
30 const static int MAX_ADV_LENGTH = 1650;
31 Bluetooth::UUID g_uuid = Bluetooth::UUID::FromString("00000000-0000-1000-8000-00805F9B34FB");
32 Bluetooth::UUID g_serviceDataUuid = Bluetooth::UUID::FromString("00000000-0000-1000-8000-00805F9B34FA");
33 Bluetooth::UUID g_serviceUuid = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
34 Bluetooth::UUID g_serviceUuidMask = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
35 Bluetooth::UUID g_serviceSolicitationUuid = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
36 Bluetooth::UUID g_serviceSolicitationUuidMask = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
37 std::string g_serviceData = "123";
38 int g_manufacturerId = 24;
39 std::string g_manufacturerData = "1567";
40 
41 std::mutex g_mx;
42 std::condition_variable g_cv;
43 bool g_ready = false;
44 int g_wait_time = 3;
45 }  // namespace
46 
InitAdvertiseSettings()47 void BleTest::InitAdvertiseSettings()
48 {
49     BleTest::bleInstance_->bleAdvertiserSettings_.SetConnectable(true);
50     BleTest::bleInstance_->bleAdvertiserSettings_.SetLegacyMode(true);
51     BleTest::bleInstance_->bleAdvertiserSettings_.SetInterval(INTERVAL);
52     BleTest::bleInstance_->bleAdvertiserSettings_.SetTxPower(BLE_ADV_TX_POWER_LEVEL::BLE_ADV_TX_POWER_MEDIUM);
53     BleTest::bleInstance_->bleAdvertiserSettings_.SetPrimaryPhy(PHY_TYPE::PHY_LE_ALL_SUPPORTED);
54     BleTest::bleInstance_->bleAdvertiserSettings_.SetSecondaryPhy(PHY_TYPE::PHY_LE_2M);
55 }
InitScanSettings()56 void BleTest::InitScanSettings()
57 {
58     BleTest::bleInstance_->bleScanSettings_.SetReportDelay(defaultInt);
59     BleTest::bleInstance_->bleScanSettings_.SetScanMode(SCAN_MODE::SCAN_MODE_LOW_POWER);
60     BleTest::bleInstance_->bleScanSettings_.SetLegacy(true);
61     BleTest::bleInstance_->bleScanSettings_.SetPhy(PHY_TYPE::PHY_LE_ALL_SUPPORTED);
62 }
63 
EnableBle()64 bool BleTest::EnableBle()
65 {
66     GTEST_LOG_(INFO) << "enable ble start";
67     std::unique_lock lock(g_mx);
68     bool isEnable = false;
69     int32_t ret = host_->EnableBle();
70     if (ret == NO_ERROR) {
71         isEnable = true;
72     }
73     EXPECT_TRUE(isEnable);
74     while (!g_ready) {
75         g_cv.wait(lock);
76     }
77     std::this_thread::sleep_for(std::chrono::seconds(g_wait_time));
78     EXPECT_TRUE(host_->IsBleEnabled());
79     GTEST_LOG_(INFO) << "enable ble end";
80     return isEnable;
81 }
82 
DisableBle()83 bool BleTest::DisableBle()
84 {
85     GTEST_LOG_(INFO) << "disable ble start";
86     std::unique_lock lock(g_mx);
87     bool isEnable = false;
88     int ret = host_->DisableBle();
89     if (ret == NO_ERROR) {
90         isEnable = true;
91     }
92     EXPECT_TRUE(isEnable);
93     while (!g_ready) {
94         g_cv.wait(lock);
95     }
96     std::this_thread::sleep_for(std::chrono::seconds(g_wait_time));
97     EXPECT_FALSE(host_->IsBleEnabled());
98     GTEST_LOG_(INFO) << "disable ble end";
99     return isEnable;
100 }
101 
HaveUuid(Bluetooth::BleAdvertiserData advData)102 bool BleTest::HaveUuid(Bluetooth::BleAdvertiserData advData)
103 {
104     for (Bluetooth::UUID uuid : advData.GetServiceUuids()) {
105         if (uuid.Equals(g_uuid)) {
106             isHaveUuid = true;
107         }
108     }
109     return isHaveUuid;
110 }
111 
ManufacturerData(Bluetooth::BleAdvertiserData advData)112 bool BleTest::ManufacturerData(Bluetooth::BleAdvertiserData advData)
113 {
114     if (advData.GetManufacturerData().empty()) {
115         return false;
116     } else {
117         std::map<uint16_t, std::string> data = advData.GetManufacturerData();
118         std::map<uint16_t, std::string>::iterator iter = data.begin();
119         for (; iter != data.end(); ++iter) {
120             if (g_manufacturerId == iter->first) {
121                 EXPECT_STREQ(g_manufacturerData.c_str(), iter->second.c_str());
122             }
123         }
124     }
125     return true;
126 }
127 
ServiceData(Bluetooth::BleAdvertiserData advData)128 bool BleTest::ServiceData(Bluetooth::BleAdvertiserData advData)
129 {
130     if (advData.GetServiceData().empty()) {
131         return false;
132     } else {
133         for (auto &iter : advData.GetServiceData()) {
134             if (g_serviceData == iter.second) {
135                 EXPECT_STREQ(g_serviceData.c_str(), iter.second.c_str());
136             }
137         }
138     }
139     return true;
140 }
141 
BleTest()142 BleTest::BleTest()
143 {
144     bleInstance_ = this;
145     host_ = &BluetoothHost::GetDefaultHost();
146 }
~BleTest()147 BleTest::~BleTest()
148 {}
149 
SetUpTestCase(void)150 void BleTest::SetUpTestCase(void)
151 {}
152 
TearDownTestCase(void)153 void BleTest::TearDownTestCase(void)
154 {}
155 
SetUp()156 void BleTest::SetUp()
157 {
158     GTEST_LOG_(INFO) << "SetUp";
159     bleHostObserverTest_ = std::make_shared<BleHostObserverTest>();
160     host_->RegisterObserver(bleHostObserverTest_);
161 }
162 
TearDown()163 void BleTest::TearDown()
164 {
165     GTEST_LOG_(INFO) << "SetUp";
166     if (bleHostObserverTest_) {
167         host_->DeregisterObserver(bleHostObserverTest_);
168     }
169 }
170 
OnStateChanged(const int transport,const int status)171 void BleHostObserverTest::OnStateChanged(const int transport, const int status)
172 {
173     GTEST_LOG_(INFO) << "OnStateChanged";
174     std::unique_lock lock(g_mx);
175     if (transport == BT_TRANSPORT_BLE) {
176         if (status == STATE_TURN_ON || status == STATE_TURN_OFF) {
177             g_ready = true;
178             g_cv.notify_all();
179         }
180     }
181 }
182 
183 
184 /**
185  * @tc.number: BLE_ModuleTest_StartAdvertising_00100
186  * @tc.name:
187  * @tc.desc:
188  */
189 HWTEST_F(BleTest, BLE_ModuleTest_StartAdvertising_00100, TestSize.Level1)
190 {
191     GTEST_LOG_(INFO) << "Ble_ModuleTest_StartAdvertising_00100 start";
192 
193     EXPECT_TRUE(EnableBle());
194     BleTest::bleInstance_->InitAdvertiseSettings();
195     std::shared_ptr<BleAdvertiser> bleAdvertise = BleAdvertiser::CreateInstance();
196     BleAdvertiserData advData;
197     BleAdvertiserData scanData;
198     advData.AddServiceUuid(g_uuid);
199     advData.AddManufacturerData(g_manufacturerId, g_manufacturerData);
200     advData.AddServiceData(g_serviceDataUuid, g_serviceData);
201     advData.SetAdvFlag(BLE_ADV_FLAG_GEN_DISC);
202     bleAdvertise->StartAdvertising(
203         BleTest::bleInstance_->bleAdvertiserSettings_, advData, scanData, 0, bleAdvertiseCallbackTest_);
204 
205     GTEST_LOG_(INFO) << "advData function test";
206     EXPECT_TRUE(BleTest::bleInstance_->HaveUuid(advData));
207     EXPECT_TRUE(BleTest::bleInstance_->ManufacturerData(advData));
208     EXPECT_TRUE(BleTest::bleInstance_->ServiceData(advData));
209     EXPECT_EQ(BLE_ADV_FLAG_GEN_DISC, advData.GetAdvFlag());
210 
211     bleAdvertise->StopAdvertising(bleAdvertiseCallbackTest_);
212     vector<uint8_t> advData1 = {1, 2, 3};
213     vector<uint8_t> scanData1 = {3, 2, 1};
214     bleAdvertise->StartAdvertising(
215         BleTest::bleInstance_->bleAdvertiserSettings_, advData1, scanData1, 0, bleAdvertiseCallbackTest_);
216     bleAdvertise->StopAdvertising(bleAdvertiseCallbackTest_);
217     int32_t length = host_->GetBleMaxAdvertisingDataLength();
218     EXPECT_LE(MIN_ADV_LENGTH, length);
219     EXPECT_GE(MAX_ADV_LENGTH, length);
220 
221     bleAdvertise->Close(bleAdvertiseCallbackTest_);
222     EXPECT_TRUE(DisableBle());
223     GTEST_LOG_(INFO) << "Ble_ModuleTest_StartAdvertising_00100 end";
224 }
225 
226 HWTEST_F(BleTest, BLE_ModuleTest_StartAdvertising_00200, TestSize.Level1)
227 {
228     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartAdvertising_00200 start";
229     BleTest::bleInstance_->InitAdvertiseSettings();
230     EXPECT_TRUE(BleTest::bleInstance_->bleAdvertiserSettings_.IsConnectable());
231     EXPECT_TRUE(BleTest::bleInstance_->bleAdvertiserSettings_.IsLegacyMode());
232     EXPECT_EQ(static_cast<uint16_t>(INTERVAL), BleTest::bleInstance_->bleAdvertiserSettings_.GetInterval());
233     EXPECT_EQ(
234         BLE_ADV_TX_POWER_LEVEL::BLE_ADV_TX_POWER_MEDIUM, BleTest::bleInstance_->bleAdvertiserSettings_.GetTxPower());
235     EXPECT_EQ(PHY_TYPE::PHY_LE_ALL_SUPPORTED, BleTest::bleInstance_->bleAdvertiserSettings_.GetPrimaryPhy());
236     EXPECT_EQ(PHY_TYPE::PHY_LE_2M, BleTest::bleInstance_->bleAdvertiserSettings_.GetSecondaryPhy());
237     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartAdvertising_00200 end";
238 }
239 
240 /**
241  * @tc.number: BLE_ModuleTest_StartCentralManager_00100
242  * @tc.name:
243  * @tc.desc:
244  */
245 HWTEST_F(BleTest, BLE_ModuleTest_StartCentralManager_00100, TestSize.Level1)
246 {
247     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartCentralManager_00100 start";
248     EXPECT_TRUE(EnableBle());
249 
250     std::vector<BleScanFilter> filters;
251     BleScanFilter filter;
252     std::string deviceId = "42:0B:AC:A0:A0:ED";
253     uint16_t manufacturerId = 0x4147;
254     std::vector<uint8_t> serviceData = {0x1f, 0x77};
255     std::vector<uint8_t> serviceDataMask = {0xff, 0xff};
256     std::vector<uint8_t> manufactureData = {0x01, 0x09, 0x20, 0x02};
257     std::vector<uint8_t> manufactureDataMask = {0x01, 0x09, 0x20, 0x02};
258     filter.SetDeviceId(deviceId);
259     filter.SetServiceUuid(g_serviceUuid);
260     filter.SetServiceUuidMask(g_serviceUuidMask);
261     filter.SetServiceSolicitationUuid(g_serviceSolicitationUuid);
262     filter.SetServiceSolicitationUuidMask(g_serviceSolicitationUuidMask);
263     filter.SetManufacturerId(manufacturerId);
264     filter.SetServiceData(serviceData);
265     filter.SetServiceDataMask(serviceDataMask);
266     filter.SetManufactureData(manufactureData);
267     filter.SetManufactureDataMask(manufactureDataMask);
268     filters.push_back(filter);
269     BleTest::bleInstance_->InitScanSettings();
270     BleCentralManager bleCentralManager(bleCentralManagerCallbackTest_);
271     bleCentralManager.StartScan(BleTest::bleInstance_->bleScanSettings_, filters);
272     EXPECT_TRUE(host_->IsBtDiscovering(1));
273     bleCentralManager.StopScan();
274     EXPECT_TRUE(DisableBle());
275 
276     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartCentralManager_00100 end";
277 }
278 
279 /**
280  * @tc.number: BLE_ModuleTest_StartCentralManager_00200
281  * @tc.name:
282  * @tc.desc:
283  */
284 
285 HWTEST_F(BleTest, BLE_ModuleTest_StartCentralManager_00200, TestSize.Level1)
286 {
287     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartCentralManager_00200 start";
288     BleTest::bleInstance_->InitScanSettings();
289     EXPECT_EQ(defaultInt, BleTest::bleInstance_->bleScanSettings_.GetReportDelayMillisValue());
290     EXPECT_EQ(SCAN_MODE::SCAN_MODE_LOW_POWER, BleTest::bleInstance_->bleScanSettings_.GetScanMode());
291     EXPECT_TRUE(BleTest::bleInstance_->bleScanSettings_.GetLegacy());
292     EXPECT_EQ(PHY_TYPE::PHY_LE_ALL_SUPPORTED, BleTest::bleInstance_->bleScanSettings_.GetPhy());
293     GTEST_LOG_(INFO) << "BLE_ModuleTest_StartCentralManager_00200 end";
294 }
295 }  // namespace Bluetooth
296 }  // namespace OHOS
297