1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/constants/ash_pref_names.h"
#include "ash/shell.h"
#include "ash/test/ash_test_base.h"
#include "components/prefs/pref_service.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ash/quick_pair/feature_status_tracker/mock_battery_saver_active_provider.h"
#include "ash/quick_pair/feature_status_tracker/mock_fast_pair_pref_enabled_provider.h"
#include "ash/quick_pair/feature_status_tracker/mock_hardware_offloading_supported_provider.h"
#include "ash/quick_pair/feature_status_tracker/mock_power_connected_provider.h"
#include "ash/quick_pair/feature_status_tracker/scanning_enabled_provider.h"
namespace {
constexpr int kNumScanningEnabledProviderCtorArgs = 4;
PrefService* GetLocalState() {
ash::Shell* shell = ash::Shell::Get();
CHECK(shell);
PrefService* pref_service = shell->local_state();
CHECK(pref_service);
return pref_service;
}
} // namespace
namespace ash::quick_pair {
class ScanningEnabledProviderTestBase : public AshTestBase {
public:
void TearDown() override {
battery_saver_provider_ = nullptr;
fast_pair_pref_enabled_provider_ = nullptr;
hardware_offloading_provider_ = nullptr;
power_connected_provider_ = nullptr;
scanning_enabled_provider_.reset();
AshTestBase::TearDown();
}
void SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus status) {
PrefService* local_state = GetLocalState();
local_state->SetInteger(ash::prefs::kSoftwareScanningEnabled,
static_cast<int>(status));
}
bool IsScanningEnabled() {
return scanning_enabled_provider_ &&
scanning_enabled_provider_->is_enabled();
}
protected:
raw_ptr<MockBatterySaverActiveProvider> battery_saver_provider_ = nullptr;
raw_ptr<MockFastPairPrefEnabledProvider> fast_pair_pref_enabled_provider_ =
nullptr;
raw_ptr<MockHardwareOffloadingSupportedProvider>
hardware_offloading_provider_ = nullptr;
raw_ptr<MockPowerConnectedProvider> power_connected_provider_ = nullptr;
std::unique_ptr<ScanningEnabledProvider> scanning_enabled_provider_;
};
class ScanningEnabledProviderTest : public ScanningEnabledProviderTestBase {
public:
void InitializeProviders(bool is_battery_saver_enabled,
bool is_fast_pair_pref_enabled,
bool is_hardware_offloading_enabled,
bool is_power_connected_enabled) {
battery_saver_provider_ = new MockBatterySaverActiveProvider();
fast_pair_pref_enabled_provider_ = new MockFastPairPrefEnabledProvider();
hardware_offloading_provider_ =
new MockHardwareOffloadingSupportedProvider();
power_connected_provider_ = new MockPowerConnectedProvider();
SetProvidersEnabled(is_battery_saver_enabled, is_fast_pair_pref_enabled,
is_hardware_offloading_enabled,
is_power_connected_enabled);
scanning_enabled_provider_ = std::make_unique<ScanningEnabledProvider>(
std::unique_ptr<BatterySaverActiveProvider>(battery_saver_provider_),
std::unique_ptr<FastPairPrefEnabledProvider>(
fast_pair_pref_enabled_provider_),
std::unique_ptr<HardwareOffloadingSupportedProvider>(
hardware_offloading_provider_),
std::unique_ptr<PowerConnectedProvider>(power_connected_provider_));
}
void SetProvidersEnabled(bool is_battery_saver_enabled,
bool is_fast_pair_pref_enabled,
bool is_hardware_offloading_enabled,
bool is_power_connected_enabled) {
CHECK(battery_saver_provider_);
CHECK(fast_pair_pref_enabled_provider_);
CHECK(hardware_offloading_provider_);
CHECK(power_connected_provider_);
ON_CALL(*battery_saver_provider_, is_enabled)
.WillByDefault(testing::Return(is_battery_saver_enabled));
ON_CALL(*fast_pair_pref_enabled_provider_, is_enabled)
.WillByDefault(testing::Return(is_fast_pair_pref_enabled));
ON_CALL(*hardware_offloading_provider_, is_enabled)
.WillByDefault(testing::Return(is_hardware_offloading_enabled));
ON_CALL(*power_connected_provider_, is_enabled)
.WillByDefault(testing::Return(is_power_connected_enabled));
}
};
// Test name anatomy: Scanning(En/Dis)abledOn[factors under test]_[remaining
// factors in scanning enabled calculation]. If scanning is expected to be
// enabled, the remaining factors will be set such that if the factors under
// test are not as expected, scanning should be disabled. Likewise, if expected
// to be disabled, the remaining factors will be set so that if the factors
// under test are unexpected, scanning will be enabled.
TEST_F(
ScanningEnabledProviderTest,
ScanningEnabledOnHardwareOffloadingSupportedFastPairPrefEnabled_BatterySaverActive_StatusNever_PowerDisconnected) {
InitializeProviders(/*is_battery_saver_enabled=*/true,
/*is_fast_pair_pref_enabled=*/true,
/*is_hardware_offloading_enabled=*/true,
/*is_power_connected_enabled=*/false);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kNever);
EXPECT_TRUE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningDisabledOnHardwareOffloadingSupportedFastPairPrefDisabled_BatterySaverActive_StatusNever_PowerDisconnected) {
InitializeProviders(/*is_battery_saver_enabled=*/true,
/*is_fast_pair_pref_enabled=*/false,
/*is_hardware_offloading_enabled=*/true,
/*is_power_connected_enabled=*/false);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kAlways);
EXPECT_FALSE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningDisabledOnBatterySaverActive_HardwareOffloadingUnsupported_FastPairPrefEnabled_StatusAlways_PowerConnected) {
InitializeProviders(/*is_battery_saver_enabled=*/true,
/*is_fast_pair_pref_enabled=*/true,
/*is_hardware_offloading_enabled=*/false,
/*is_power_connected_enabled=*/true);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kAlways);
EXPECT_FALSE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningEnabledOnStatusAlways_HardwareOffloadingUnsupported_FastPairPrefDisabled_BatterySaverInactive_PowerDisconnected) {
InitializeProviders(/*is_battery_saver_enabled=*/false,
/*is_fast_pair_pref_enabled=*/false,
/*is_hardware_offloading_enabled=*/false,
/*is_power_connected_enabled=*/false);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kAlways);
EXPECT_TRUE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningDisabledOnStatusWhenChargingAndPowerDisconnected_HardwareOffloadingUnsupported_FastPairPrefEnabled_BatterySaverInactive) {
InitializeProviders(/*is_battery_saver_enabled=*/false,
/*is_fast_pair_pref_enabled=*/true,
/*is_hardware_offloading_enabled=*/false,
/*is_power_connected_enabled=*/false);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kOnlyWhenCharging);
EXPECT_FALSE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningEnabledOnStatusWhenChargingAndPowerConnected_HardwareOffloadingUnsupported_FastPairPrefDisabled_BatterySaverInactive) {
InitializeProviders(/*is_battery_saver_enabled=*/false,
/*is_fast_pair_pref_enabled=*/false,
/*is_hardware_offloading_enabled=*/false,
/*is_power_connected_enabled=*/true);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kOnlyWhenCharging);
EXPECT_TRUE(IsScanningEnabled());
}
TEST_F(
ScanningEnabledProviderTest,
ScanningDisabledOnStatusNever_HardwareOffloadingUnsupported_FastPairPrefEnabled_BatterySaverInactive_PowerConnected) {
InitializeProviders(/*is_battery_saver_enabled=*/false,
/*is_fast_pair_pref_enabled=*/true,
/*is_hardware_offloading_enabled=*/false,
/*is_power_connected_enabled=*/true);
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kNever);
EXPECT_FALSE(IsScanningEnabled());
}
class ScanningEnabledProviderNoCrashOnNullInputsTest
: public ScanningEnabledProviderTest,
public testing::WithParamInterface<size_t> {
public:
// Initialize each argument to `scanning_enabled_provider_` with either
// a `unique_ptr` of expected type or a `nullptr` depending on whether the bit
// in `args_mask` corresponding to the argument's place in order is 1 or 0,
// respectively. Return values to each mock's `is_enabled` such that,
// in the evaluation of the logical expression in
// `ScanningEnabledProvider::IsScanningEnabled`, each subprovider will be
// accessed if the providers accessed before it in evaluation order are
// non-null except for the FastPairPrefEnabledProvider, which will be checked
// in the case that only it and the HardwareOffloadingSupportedProvider are
// non-null and all other providers are null.
void InitializeProviders(size_t args_mask) {
bool is_battery_saver_nonnull = args_mask & 1;
bool is_fast_pair_pref_nonnull = args_mask & 2;
bool is_hardware_offloading_nonnull = args_mask & 4;
bool is_power_connected_nonnull = args_mask & 8;
if (is_battery_saver_nonnull) {
battery_saver_provider_ = new MockBatterySaverActiveProvider();
ON_CALL(*battery_saver_provider_, is_enabled)
.WillByDefault(testing::Return(false));
}
if (is_fast_pair_pref_nonnull) {
fast_pair_pref_enabled_provider_ = new MockFastPairPrefEnabledProvider();
ON_CALL(*fast_pair_pref_enabled_provider_, is_enabled)
.WillByDefault(testing::Return(true));
}
if (is_hardware_offloading_nonnull) {
hardware_offloading_provider_ =
new MockHardwareOffloadingSupportedProvider();
ON_CALL(*hardware_offloading_provider_, is_enabled)
.WillByDefault(testing::Return(
is_hardware_offloading_nonnull && is_fast_pair_pref_nonnull &&
!is_battery_saver_nonnull && !is_power_connected_nonnull));
}
if (is_power_connected_nonnull) {
power_connected_provider_ = new MockPowerConnectedProvider();
ON_CALL(*power_connected_provider_, is_enabled)
.WillByDefault(testing::Return(false));
}
scanning_enabled_provider_ = std::make_unique<ScanningEnabledProvider>(
(is_battery_saver_nonnull ? std::unique_ptr<BatterySaverActiveProvider>(
battery_saver_provider_)
: nullptr),
(is_fast_pair_pref_nonnull
? std::unique_ptr<FastPairPrefEnabledProvider>(
fast_pair_pref_enabled_provider_)
: nullptr),
(is_hardware_offloading_nonnull
? std::unique_ptr<HardwareOffloadingSupportedProvider>(
hardware_offloading_provider_)
: nullptr),
(is_power_connected_nonnull ? std::unique_ptr<PowerConnectedProvider>(
power_connected_provider_)
: nullptr));
}
};
// This parametrized test initializes `scanning_enabled_provider_` with all
// combinations of `nullptr` and non-null inputs. If it doesn't crash, it's
// considered passed.
TEST_P(ScanningEnabledProviderNoCrashOnNullInputsTest, NoCrashOnNullInputs) {
SetSoftwareScanningStatus(
ScanningEnabledProvider::SoftwareScanningStatus::kAlways);
InitializeProviders(/*args_mask=*/GetParam());
IsScanningEnabled();
}
INSTANTIATE_TEST_SUITE_P(
ScanningEnabledProviderNoCrashOnNullInputsTest,
ScanningEnabledProviderNoCrashOnNullInputsTest,
testing::Range<size_t>(0, 1 << kNumScanningEnabledProviderCtorArgs));
} // namespace ash::quick_pair
|
