diff options
Diffstat (limited to 'tests/offload_scan_manager_test.cpp')
-rw-r--r-- | tests/offload_scan_manager_test.cpp | 87 |
1 files changed, 27 insertions, 60 deletions
diff --git a/tests/offload_scan_manager_test.cpp b/tests/offload_scan_manager_test.cpp index 2dbf953..9e586cb 100644 --- a/tests/offload_scan_manager_test.cpp +++ b/tests/offload_scan_manager_test.cpp | |||
@@ -23,6 +23,7 @@ | |||
23 | #include <gtest/gtest.h> | 23 | #include <gtest/gtest.h> |
24 | 24 | ||
25 | #include "wificond/tests/mock_offload.h" | 25 | #include "wificond/tests/mock_offload.h" |
26 | #include "wificond/tests/mock_offload_scan_callback_interface.h" | ||
26 | #include "wificond/tests/mock_offload_service_utils.h" | 27 | #include "wificond/tests/mock_offload_service_utils.h" |
27 | #include "wificond/tests/offload_hal_test_constants.h" | 28 | #include "wificond/tests/offload_hal_test_constants.h" |
28 | #include "wificond/tests/offload_test_utils.h" | 29 | #include "wificond/tests/offload_test_utils.h" |
@@ -112,6 +113,9 @@ class OffloadScanManagerTest : public ::testing::Test { | |||
112 | sp<OffloadDeathRecipient> death_recipient_; | 113 | sp<OffloadDeathRecipient> death_recipient_; |
113 | shared_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{ | 114 | shared_ptr<NiceMock<MockOffloadServiceUtils>> mock_offload_service_utils_{ |
114 | new NiceMock<MockOffloadServiceUtils>()}; | 115 | new NiceMock<MockOffloadServiceUtils>()}; |
116 | shared_ptr<NiceMock<MockOffloadScanCallbackInterface>> | ||
117 | mock_offload_scan_callback_interface_{ | ||
118 | new NiceMock<MockOffloadScanCallbackInterface>()}; | ||
115 | unique_ptr<OffloadScanManager> offload_scan_manager_; | 119 | unique_ptr<OffloadScanManager> offload_scan_manager_; |
116 | OffloadStatus status; | 120 | OffloadStatus status; |
117 | vector<vector<uint8_t>> scan_ssids{kSsid1, kSsid2}; | 121 | vector<vector<uint8_t>> scan_ssids{kSsid1, kSsid2}; |
@@ -131,8 +135,8 @@ TEST_F(OffloadScanManagerTest, BinderDeathRegisteredCookieAndService) { | |||
131 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 135 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
132 | .WillByDefault(testing::Return(mock_offload_)); | 136 | .WillByDefault(testing::Return(mock_offload_)); |
133 | offload_scan_manager_.reset(new OffloadScanManager( | 137 | offload_scan_manager_.reset(new OffloadScanManager( |
134 | mock_offload_service_utils_, | 138 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
135 | [](vector<NativeScanResult> scanResult) -> void {})); | 139 | EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadError(_)); |
136 | death_recipient_->serviceDied(cookie_, mock_offload_); | 140 | death_recipient_->serviceDied(cookie_, mock_offload_); |
137 | EXPECT_EQ(OffloadScanManager::kNoService, | 141 | EXPECT_EQ(OffloadScanManager::kNoService, |
138 | offload_scan_manager_->getOffloadStatus()); | 142 | offload_scan_manager_->getOffloadStatus()); |
@@ -147,8 +151,7 @@ TEST_F(OffloadScanManagerTest, BinderDeathUnregisteredCookie) { | |||
147 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 151 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
148 | .WillByDefault(testing::Return(mock_offload_)); | 152 | .WillByDefault(testing::Return(mock_offload_)); |
149 | offload_scan_manager_.reset(new OffloadScanManager( | 153 | offload_scan_manager_.reset(new OffloadScanManager( |
150 | mock_offload_service_utils_, | 154 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
151 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
152 | death_recipient_->serviceDied(kDeathCode, mock_offload_); | 155 | death_recipient_->serviceDied(kDeathCode, mock_offload_); |
153 | EXPECT_FALSE(OffloadScanManager::kNoService == | 156 | EXPECT_FALSE(OffloadScanManager::kNoService == |
154 | offload_scan_manager_->getOffloadStatus()); | 157 | offload_scan_manager_->getOffloadStatus()); |
@@ -163,8 +166,7 @@ TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) { | |||
163 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 166 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
164 | .WillByDefault(testing::Return(nullptr)); | 167 | .WillByDefault(testing::Return(nullptr)); |
165 | offload_scan_manager_.reset(new OffloadScanManager( | 168 | offload_scan_manager_.reset(new OffloadScanManager( |
166 | mock_offload_service_utils_, | 169 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
167 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
168 | EXPECT_EQ(OffloadScanManager::kNoService, | 170 | EXPECT_EQ(OffloadScanManager::kNoService, |
169 | offload_scan_manager_->getOffloadStatus()); | 171 | offload_scan_manager_->getOffloadStatus()); |
170 | } | 172 | } |
@@ -180,8 +182,7 @@ TEST_F(OffloadScanManagerTest, ServiceAvailableTest) { | |||
180 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 182 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
181 | .WillByDefault(testing::Return(mock_offload_)); | 183 | .WillByDefault(testing::Return(mock_offload_)); |
182 | offload_scan_manager_.reset(new OffloadScanManager( | 184 | offload_scan_manager_.reset(new OffloadScanManager( |
183 | mock_offload_service_utils_, | 185 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
184 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
185 | EXPECT_EQ(OffloadScanManager::kNoError, | 186 | EXPECT_EQ(OffloadScanManager::kNoError, |
186 | offload_scan_manager_->getOffloadStatus()); | 187 | offload_scan_manager_->getOffloadStatus()); |
187 | } | 188 | } |
@@ -192,21 +193,17 @@ TEST_F(OffloadScanManagerTest, ServiceAvailableTest) { | |||
192 | * scan results are available | 193 | * scan results are available |
193 | */ | 194 | */ |
194 | TEST_F(OffloadScanManagerTest, CallbackInvokedTest) { | 195 | TEST_F(OffloadScanManagerTest, CallbackInvokedTest) { |
195 | bool callback_invoked = false; | ||
196 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); | 196 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
197 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); | 197 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); |
198 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); | 198 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); |
199 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 199 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
200 | .WillByDefault(testing::Return(mock_offload_)); | 200 | .WillByDefault(testing::Return(mock_offload_)); |
201 | EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadScanResult()); | ||
201 | offload_scan_manager_.reset(new OffloadScanManager( | 202 | offload_scan_manager_.reset(new OffloadScanManager( |
202 | mock_offload_service_utils_, | 203 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
203 | [&callback_invoked](vector<NativeScanResult> scanResult) -> void { | ||
204 | callback_invoked = true; | ||
205 | })); | ||
206 | vector<ScanResult> dummy_scan_results_ = | 204 | vector<ScanResult> dummy_scan_results_ = |
207 | OffloadTestUtils::createOffloadScanResults(); | 205 | OffloadTestUtils::createOffloadScanResults(); |
208 | offload_callback_->onScanResult(dummy_scan_results_); | 206 | offload_callback_->onScanResult(dummy_scan_results_); |
209 | EXPECT_EQ(true, callback_invoked); | ||
210 | } | 207 | } |
211 | 208 | ||
212 | /** | 209 | /** |
@@ -220,10 +217,10 @@ TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) { | |||
220 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 217 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
221 | .WillByDefault(testing::Return(mock_offload_)); | 218 | .WillByDefault(testing::Return(mock_offload_)); |
222 | offload_scan_manager_.reset(new OffloadScanManager( | 219 | offload_scan_manager_.reset(new OffloadScanManager( |
223 | mock_offload_service_utils_, | 220 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
224 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
225 | OffloadStatus status = | 221 | OffloadStatus status = |
226 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); | 222 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); |
223 | EXPECT_CALL(*mock_offload_scan_callback_interface_, OnOffloadError(_)); | ||
227 | offload_callback_->onError(status); | 224 | offload_callback_->onError(status); |
228 | EXPECT_EQ(offload_scan_manager_->getOffloadStatus(), | 225 | EXPECT_EQ(offload_scan_manager_->getOffloadStatus(), |
229 | OffloadScanManager::kError); | 226 | OffloadScanManager::kError); |
@@ -240,8 +237,7 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) { | |||
240 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 237 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
241 | .WillByDefault(testing::Return(mock_offload_)); | 238 | .WillByDefault(testing::Return(mock_offload_)); |
242 | offload_scan_manager_.reset(new OffloadScanManager( | 239 | offload_scan_manager_.reset(new OffloadScanManager( |
243 | mock_offload_service_utils_, | 240 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
244 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
245 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); | 241 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
246 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); | 242 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
247 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; | 243 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
@@ -256,12 +252,11 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) { | |||
256 | * Offload HAL when service is not available | 252 | * Offload HAL when service is not available |
257 | */ | 253 | */ |
258 | TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) { | 254 | TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) { |
259 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); | 255 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()).Times(2); |
260 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 256 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
261 | .WillByDefault(testing::Return(nullptr)); | 257 | .WillByDefault(testing::Return(nullptr)); |
262 | offload_scan_manager_.reset(new OffloadScanManager( | 258 | offload_scan_manager_.reset(new OffloadScanManager( |
263 | mock_offload_service_utils_, | 259 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
264 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
265 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; | 260 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
266 | bool result = offload_scan_manager_->startScan( | 261 | bool result = offload_scan_manager_->startScan( |
267 | kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, | 262 | kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
@@ -281,8 +276,7 @@ TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) { | |||
281 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 276 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
282 | .WillByDefault(testing::Return(mock_offload_)); | 277 | .WillByDefault(testing::Return(mock_offload_)); |
283 | offload_scan_manager_.reset(new OffloadScanManager( | 278 | offload_scan_manager_.reset(new OffloadScanManager( |
284 | mock_offload_service_utils_, | 279 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
285 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
286 | OffloadStatus status = | 280 | OffloadStatus status = |
287 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); | 281 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
288 | offload_callback_->onError(status); | 282 | offload_callback_->onError(status); |
@@ -305,9 +299,8 @@ TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) { | |||
305 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 299 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
306 | .WillByDefault(testing::Return(mock_offload_)); | 300 | .WillByDefault(testing::Return(mock_offload_)); |
307 | offload_scan_manager_.reset(new OffloadScanManager( | 301 | offload_scan_manager_.reset(new OffloadScanManager( |
308 | mock_offload_service_utils_, | 302 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
309 | [](vector<NativeScanResult> scanResult) -> void {})); | 303 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(2); |
310 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(1); | ||
311 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(2); | 304 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(2); |
312 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; | 305 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
313 | bool result = offload_scan_manager_->startScan( | 306 | bool result = offload_scan_manager_->startScan( |
@@ -331,8 +324,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) { | |||
331 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 324 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
332 | .WillByDefault(testing::Return(mock_offload_)); | 325 | .WillByDefault(testing::Return(mock_offload_)); |
333 | offload_scan_manager_.reset(new OffloadScanManager( | 326 | offload_scan_manager_.reset(new OffloadScanManager( |
334 | mock_offload_service_utils_, | 327 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
335 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
336 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); | 328 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
337 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); | 329 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
338 | EXPECT_CALL(*mock_offload_, unsubscribeScanResults()); | 330 | EXPECT_CALL(*mock_offload_, unsubscribeScanResults()); |
@@ -347,26 +339,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) { | |||
347 | 339 | ||
348 | /** | 340 | /** |
349 | * Testing OffloadScanManager for unsubscribing to the scan results from | 341 | * Testing OffloadScanManager for unsubscribing to the scan results from |
350 | * Offload HAL without first subscribing | 342 | * when service is not connected to the hardware |
351 | */ | ||
352 | TEST_F(OffloadScanManagerTest, StopScanTestWithoutStartWhenServiceIsOk) { | ||
353 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); | ||
354 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadCallback(_)); | ||
355 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadDeathRecipient(_)); | ||
356 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | ||
357 | .WillByDefault(testing::Return(mock_offload_)); | ||
358 | offload_scan_manager_.reset(new OffloadScanManager( | ||
359 | mock_offload_service_utils_, | ||
360 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
361 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; | ||
362 | bool result = offload_scan_manager_->stopScan(&reason_code); | ||
363 | EXPECT_EQ(result, false); | ||
364 | EXPECT_EQ(reason_code, OffloadScanManager::kNotSubscribed); | ||
365 | } | ||
366 | |||
367 | /** | ||
368 | * Testing OffloadScanManager for unsubscribing to the scan results from | ||
369 | * Offload HAL without first subscribing when service is not working correctly | ||
370 | */ | 343 | */ |
371 | TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) { | 344 | TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) { |
372 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); | 345 | EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService()); |
@@ -374,11 +347,9 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) { | |||
374 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 347 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
375 | .WillByDefault(testing::Return(mock_offload_)); | 348 | .WillByDefault(testing::Return(mock_offload_)); |
376 | offload_scan_manager_.reset(new OffloadScanManager( | 349 | offload_scan_manager_.reset(new OffloadScanManager( |
377 | mock_offload_service_utils_, | 350 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
378 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
379 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); | 351 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)); |
380 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); | 352 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)); |
381 | EXPECT_CALL(*mock_offload_, unsubscribeScanResults()); | ||
382 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; | 353 | OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone; |
383 | bool result = offload_scan_manager_->startScan( | 354 | bool result = offload_scan_manager_->startScan( |
384 | kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, | 355 | kDisconnectedModeScanIntervalMs, kRssiThreshold, scan_ssids, match_ssids, |
@@ -388,7 +359,7 @@ TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) { | |||
388 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); | 359 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
389 | offload_callback_->onError(status); | 360 | offload_callback_->onError(status); |
390 | result = offload_scan_manager_->stopScan(&reason_code); | 361 | result = offload_scan_manager_->stopScan(&reason_code); |
391 | EXPECT_EQ(result, true); | 362 | EXPECT_EQ(result, false); |
392 | } | 363 | } |
393 | 364 | ||
394 | /** | 365 | /** |
@@ -402,8 +373,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsOk) { | |||
402 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 373 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
403 | .WillByDefault(testing::Return(mock_offload_)); | 374 | .WillByDefault(testing::Return(mock_offload_)); |
404 | offload_scan_manager_.reset(new OffloadScanManager( | 375 | offload_scan_manager_.reset(new OffloadScanManager( |
405 | mock_offload_service_utils_, | 376 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
406 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
407 | EXPECT_CALL(*mock_offload_, getScanStats(_)); | 377 | EXPECT_CALL(*mock_offload_, getScanStats(_)); |
408 | NativeScanStats stats; | 378 | NativeScanStats stats; |
409 | bool result = offload_scan_manager_->getScanStats(&stats); | 379 | bool result = offload_scan_manager_->getScanStats(&stats); |
@@ -421,8 +391,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsTestWhenServiceIsNotOk) { | |||
421 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 391 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
422 | .WillByDefault(testing::Return(mock_offload_)); | 392 | .WillByDefault(testing::Return(mock_offload_)); |
423 | offload_scan_manager_.reset(new OffloadScanManager( | 393 | offload_scan_manager_.reset(new OffloadScanManager( |
424 | mock_offload_service_utils_, | 394 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
425 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
426 | OffloadStatus status = | 395 | OffloadStatus status = |
427 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); | 396 | OffloadTestUtils::createOffloadStatus(OffloadStatusCode::NO_CONNECTION); |
428 | offload_callback_->onError(status); | 397 | offload_callback_->onError(status); |
@@ -443,8 +412,7 @@ TEST_F(OffloadScanManagerTest, StartScanFailedTest) { | |||
443 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 412 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
444 | .WillByDefault(testing::Return(mock_offload_)); | 413 | .WillByDefault(testing::Return(mock_offload_)); |
445 | offload_scan_manager_.reset(new OffloadScanManager( | 414 | offload_scan_manager_.reset(new OffloadScanManager( |
446 | mock_offload_service_utils_, | 415 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
447 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
448 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(0); | 416 | EXPECT_CALL(*mock_offload_, subscribeScanResults(_, _)).Times(0); |
449 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(1); | 417 | EXPECT_CALL(*mock_offload_, configureScans(_, _, _)).Times(1); |
450 | status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); | 418 | status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::ERROR); |
@@ -467,8 +435,7 @@ TEST_F(OffloadScanManagerTest, getScanStatsFailedTest) { | |||
467 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) | 435 | ON_CALL(*mock_offload_service_utils_, GetOffloadService()) |
468 | .WillByDefault(testing::Return(mock_offload_)); | 436 | .WillByDefault(testing::Return(mock_offload_)); |
469 | offload_scan_manager_.reset(new OffloadScanManager( | 437 | offload_scan_manager_.reset(new OffloadScanManager( |
470 | mock_offload_service_utils_, | 438 | mock_offload_service_utils_, mock_offload_scan_callback_interface_)); |
471 | [](vector<NativeScanResult> scanResult) -> void {})); | ||
472 | status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::TIMEOUT); | 439 | status = OffloadTestUtils::createOffloadStatus(OffloadStatusCode::TIMEOUT); |
473 | EXPECT_CALL(*mock_offload_, getScanStats(_)); | 440 | EXPECT_CALL(*mock_offload_, getScanStats(_)); |
474 | NativeScanStats stats; | 441 | NativeScanStats stats; |