1 /*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "gtest/gtest.h"
18
19 #include "chre/core/ble_request.h"
20
21 using chre::BleRequest;
22
TEST(BleRequest,DefaultMinimalRequest)23 TEST(BleRequest, DefaultMinimalRequest) {
24 BleRequest request;
25 EXPECT_FALSE(request.isEnabled());
26 EXPECT_EQ(CHRE_BLE_SCAN_MODE_BACKGROUND, request.getMode());
27 EXPECT_EQ(0, request.getReportDelayMs());
28 EXPECT_TRUE(request.getGenericFilters().empty());
29 EXPECT_EQ(CHRE_BLE_RSSI_THRESHOLD_NONE, request.getRssiThreshold());
30 }
31
TEST(BleRequest,AggressiveModeIsHigherThanBackground)32 TEST(BleRequest, AggressiveModeIsHigherThanBackground) {
33 BleRequest backgroundMode(0 /* instanceId */, true /* enable */,
34 CHRE_BLE_SCAN_MODE_BACKGROUND,
35 0 /* reportDelayMs */, nullptr /* filter */);
36 BleRequest aggressiveMode(0 /* instanceId */, true /* enable */,
37 CHRE_BLE_SCAN_MODE_AGGRESSIVE,
38 0 /* reportDelayMs */, nullptr /* filter */);
39
40 BleRequest mergedRequest;
41 EXPECT_TRUE(mergedRequest.mergeWith(aggressiveMode));
42 EXPECT_FALSE(mergedRequest.mergeWith(backgroundMode));
43
44 EXPECT_TRUE(mergedRequest.isEnabled());
45 EXPECT_EQ(CHRE_BLE_SCAN_MODE_AGGRESSIVE, mergedRequest.getMode());
46 EXPECT_TRUE(mergedRequest.getGenericFilters().empty());
47 EXPECT_EQ(CHRE_BLE_RSSI_THRESHOLD_NONE, mergedRequest.getRssiThreshold());
48 }
49
TEST(BleRequest,MergeWithReplacesParametersOfDisabledRequest)50 TEST(BleRequest, MergeWithReplacesParametersOfDisabledRequest) {
51 chreBleScanFilter filter;
52 filter.rssiThreshold = -5;
53 filter.scanFilterCount = 1;
54 auto scanFilters = std::make_unique<chreBleGenericFilter>();
55 scanFilters->type = CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16;
56 scanFilters->len = 2;
57 filter.scanFilters = scanFilters.get();
58 BleRequest enabled(0, true, CHRE_BLE_SCAN_MODE_AGGRESSIVE, 20, &filter);
59
60 BleRequest mergedRequest;
61 EXPECT_FALSE(mergedRequest.isEnabled());
62 EXPECT_TRUE(mergedRequest.mergeWith(enabled));
63 EXPECT_TRUE(mergedRequest.isEnabled());
64 EXPECT_EQ(CHRE_BLE_SCAN_MODE_AGGRESSIVE, mergedRequest.getMode());
65 EXPECT_EQ(20, mergedRequest.getReportDelayMs());
66 EXPECT_EQ(-5, mergedRequest.getRssiThreshold());
67 EXPECT_EQ(1, mergedRequest.getGenericFilters().size());
68 EXPECT_EQ(CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16,
69 mergedRequest.getGenericFilters()[0].type);
70 EXPECT_EQ(2, mergedRequest.getGenericFilters()[0].len);
71 }
72
TEST(BleRequest,IsEquivalentToBasic)73 TEST(BleRequest, IsEquivalentToBasic) {
74 BleRequest backgroundMode(0 /* instanceId */, true /* enable */,
75 CHRE_BLE_SCAN_MODE_BACKGROUND,
76 0 /* reportDelayMs */, nullptr /* filter */);
77 EXPECT_TRUE(backgroundMode.isEquivalentTo(backgroundMode));
78 }
79
TEST(BleRequest,IsNotEquivalentToBasic)80 TEST(BleRequest, IsNotEquivalentToBasic) {
81 BleRequest backgroundMode(0 /* instanceId */, true /* enable */,
82 CHRE_BLE_SCAN_MODE_BACKGROUND,
83 0 /* reportDelayMs */, nullptr /* filter */);
84 BleRequest aggressiveMode(0 /* instanceId */, true /* enable */,
85 CHRE_BLE_SCAN_MODE_AGGRESSIVE,
86 0 /* reportDelayMs */, nullptr /* filter */);
87 EXPECT_FALSE(backgroundMode.isEquivalentTo(aggressiveMode));
88 }
89
TEST(BleRequest,IsEquivalentToAdvanced)90 TEST(BleRequest, IsEquivalentToAdvanced) {
91 chreBleScanFilter filter;
92 filter.rssiThreshold = -5;
93 filter.scanFilterCount = 1;
94 auto scanFilters = std::make_unique<chreBleGenericFilter>();
95 scanFilters->type = CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16;
96 scanFilters->len = 4;
97 filter.scanFilters = scanFilters.get();
98
99 BleRequest backgroundMode(100 /* instanceId */, true /* enable */,
100 CHRE_BLE_SCAN_MODE_BACKGROUND,
101 100 /* reportDelayMs */, &filter);
102 EXPECT_TRUE(backgroundMode.isEquivalentTo(backgroundMode));
103 }
104
TEST(BleRequest,IsNotEquivalentToAdvanced)105 TEST(BleRequest, IsNotEquivalentToAdvanced) {
106 chreBleScanFilter filter;
107 filter.rssiThreshold = -5;
108 filter.scanFilterCount = 1;
109 auto scanFilters = std::make_unique<chreBleGenericFilter>();
110 scanFilters->type = CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16;
111 scanFilters->len = 4;
112 filter.scanFilters = scanFilters.get();
113
114 BleRequest backgroundMode(100 /* instanceId */, true /* enable */,
115 CHRE_BLE_SCAN_MODE_BACKGROUND,
116 100 /* reportDelayMs */, &filter /* filter */);
117 BleRequest aggressiveMode(0 /* instanceId */, true /* enable */,
118 CHRE_BLE_SCAN_MODE_AGGRESSIVE,
119 0 /* reportDelayMs */, nullptr /* filter */);
120
121 EXPECT_FALSE(backgroundMode.isEquivalentTo(aggressiveMode));
122 }
123
TEST(BleRequest,GetScanFilter)124 TEST(BleRequest, GetScanFilter) {
125 chreBleScanFilter filter;
126 filter.rssiThreshold = -5;
127 filter.scanFilterCount = 1;
128 auto scanFilters = std::make_unique<chreBleGenericFilter>();
129 scanFilters->type = CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16;
130 scanFilters->len = 4;
131 filter.scanFilters = scanFilters.get();
132
133 BleRequest backgroundMode(100 /* instanceId */, true /* enable */,
134 CHRE_BLE_SCAN_MODE_BACKGROUND,
135 100 /* reportDelayMs */, &filter /* filter */);
136
137 chreBleScanFilter retFilter = backgroundMode.getScanFilter();
138 EXPECT_EQ(filter.rssiThreshold, retFilter.rssiThreshold);
139 EXPECT_EQ(filter.scanFilterCount, retFilter.scanFilterCount);
140 EXPECT_EQ(0, memcmp(scanFilters.get(), retFilter.scanFilters,
141 sizeof(chreBleGenericFilter)));
142 }
143