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
23namespace OHOS {
24namespace Bluetooth {
25BleTest *BleTest::bleInstance_ = nullptr;
26namespace {
27const static int defaultInt = 150;
28const static int INTERVAL = 350;
29const static int MIN_ADV_LENGTH = 31;
30const static int MAX_ADV_LENGTH = 1650;
31Bluetooth::UUID g_uuid = Bluetooth::UUID::FromString("00000000-0000-1000-8000-00805F9B34FB");
32Bluetooth::UUID g_serviceDataUuid = Bluetooth::UUID::FromString("00000000-0000-1000-8000-00805F9B34FA");
33Bluetooth::UUID g_serviceUuid = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
34Bluetooth::UUID g_serviceUuidMask = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
35Bluetooth::UUID g_serviceSolicitationUuid = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
36Bluetooth::UUID g_serviceSolicitationUuidMask = Bluetooth::UUID::FromString("FFFFFFF0-FFFF-FFFF-FFFF-FFFFFFFFFFFF");
37std::string g_serviceData = "123";
38int g_manufacturerId = 24;
39std::string g_manufacturerData = "1567";
40
41std::mutex g_mx;
42std::condition_variable g_cv;
43bool g_ready = false;
44int g_wait_time = 3;
45}  // namespace
46
47void 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}
56void 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
64bool 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
83bool 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
102bool 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
112bool 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
128bool 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
142BleTest::BleTest()
143{
144    bleInstance_ = this;
145    host_ = &BluetoothHost::GetDefaultHost();
146}
147BleTest::~BleTest()
148{}
149
150void BleTest::SetUpTestCase(void)
151{}
152
153void BleTest::TearDownTestCase(void)
154{}
155
156void BleTest::SetUp()
157{
158    GTEST_LOG_(INFO) << "SetUp";
159    bleHostObserverTest_ = std::make_shared<BleHostObserverTest>();
160    host_->RegisterObserver(bleHostObserverTest_);
161}
162
163void BleTest::TearDown()
164{
165    GTEST_LOG_(INFO) << "SetUp";
166    if (bleHostObserverTest_) {
167        host_->DeregisterObserver(bleHostObserverTest_);
168    }
169}
170
171void 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 */
189HWTEST_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
226HWTEST_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 */
245HWTEST_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
285HWTEST_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