message_stream_unittest.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/quick_pair/message_stream/message_stream.h"
  5. #include <memory>
  6. #include "ash/quick_pair/common/logging.h"
  7. #include "ash/quick_pair/message_stream/fake_bluetooth_socket.h"
  8. #include "ash/services/quick_pair/fast_pair_data_parser.h"
  9. #include "ash/services/quick_pair/mock_quick_pair_process_manager.h"
  10. #include "ash/services/quick_pair/quick_pair_process.h"
  11. #include "ash/services/quick_pair/quick_pair_process_manager.h"
  12. #include "ash/services/quick_pair/quick_pair_process_manager_impl.h"
  13. #include "base/callback.h"
  14. #include "base/callback_helpers.h"
  15. #include "base/memory/scoped_refptr.h"
  16. #include "base/run_loop.h"
  17. #include "base/test/metrics/histogram_tester.h"
  18. #include "base/test/mock_callback.h"
  19. #include "base/test/task_environment.h"
  20. #include "device/bluetooth/bluetooth_socket.h"
  21. #include "testing/gtest/include/gtest/gtest.h"
  22. namespace {
  23. const std::vector<uint8_t> kModelIdBytes = {/*mesage_group=*/0x03,
  24. /*mesage_code=*/0x01,
  25. /*additional_data_length=*/0x00,
  26. 0x03,
  27. /*additional_data=*/0xAA,
  28. 0xBB,
  29. 0xCC};
  30. const std::vector<uint8_t> kInvalidBytes = {/*mesage_group=*/0x03,
  31. /*mesage_code=*/0x09,
  32. /*additional_data_length=*/0x00,
  33. 0x03,
  34. /*additional_data=*/0xAA,
  35. 0xBB,
  36. 0xCC};
  37. const std::vector<uint8_t> kModelIdBleAddressBytes = {
  38. /*mesage_group=*/0x03,
  39. /*mesage_code=*/0x01,
  40. /*additional_data_length=*/0x00,
  41. 0x03,
  42. /*additional_data=*/0xAA,
  43. 0xBB,
  44. 0xCC,
  45. /*mesage_group=*/0x03,
  46. /*mesage_code=*/0x02,
  47. /*additional_data_length=*/0x00,
  48. 0x06,
  49. /*additional_data=*/0xAA,
  50. 0xBB,
  51. 0xCC,
  52. 0xDD,
  53. 0xEE,
  54. 0xFF};
  55. const std::vector<uint8_t> kNakBytes = {/*mesage_group=*/0xFF,
  56. /*mesage_code=*/0x02,
  57. /*additional_data_length=*/0x00,
  58. 0x03,
  59. /*additional_data=*/0x00,
  60. 0x04,
  61. 0x01};
  62. const std::vector<uint8_t> kRingDeviceBytes = {/*mesage_group=*/0x04,
  63. /*mesage_code=*/0x01,
  64. /*additional_data_length=*/0x00,
  65. 0x02,
  66. /*additional_data=*/0x01,
  67. 0x3C};
  68. const std::vector<uint8_t> kPlatformBytes = {/*mesage_group=*/0x03,
  69. /*mesage_code=*/0x08,
  70. /*additional_data_length=*/0x00,
  71. 0x02,
  72. /*additional_data=*/0x01,
  73. 0x1C};
  74. const std::vector<uint8_t> kActiveComponentBytes = {
  75. /*mesage_group=*/0x03, /*mesage_code=*/0x06,
  76. /*additional_data_length=*/0x00, 0x01,
  77. /*additional_data=*/0x03};
  78. const std::vector<uint8_t> kRemainingBatteryTimeBytes = {
  79. /*mesage_group=*/0x03, /*mesage_code=*/0x04,
  80. /*additional_data_length=*/0x00, 0x02,
  81. /*additional_data=*/0x01, 0x0F};
  82. const std::vector<uint8_t> kBatteryUpdateBytes = {
  83. /*mesage_group=*/0x03,
  84. /*mesage_code=*/0x03,
  85. /*additional_data_length=*/0x00,
  86. 0x03,
  87. /*additional_data=*/0x57,
  88. 0x41,
  89. 0x7F};
  90. const std::vector<uint8_t> kEnableSilenceModeBytes = {
  91. /*mesage_group=*/0x01,
  92. /*mesage_code=*/0x01,
  93. /*additional_data_length=*/0x00, 0x00};
  94. const std::vector<uint8_t> kCompanionAppLogBufferFullBytes = {
  95. /*mesage_group=*/0x02,
  96. /*mesage_code=*/0x01,
  97. /*additional_data_length=*/0x00, 0x00};
  98. const std::string kModelIdString = "AABBCC";
  99. const std::string kBleAddressString = "AA:BB:CC:DD:EE:FF";
  100. constexpr int kMaxRetryCount = 10;
  101. constexpr int kMessageStorageCapacity = 1000;
  102. constexpr char kTestDeviceAddress[] = "11:12:13:14:15:16";
  103. const char kMessageStreamReceiveResultMetric[] =
  104. "Bluetooth.ChromeOS.FastPair.MessageStream.Receive.Result";
  105. const char kMessageStreamReceiveErrorMetric[] =
  106. "Bluetooth.ChromeOS.FastPair.MessageStream.Receive.ErrorReason";
  107. class FakeQuickPairProcessManager
  108. : public ash::quick_pair::QuickPairProcessManager {
  109. public:
  110. FakeQuickPairProcessManager(
  111. base::test::SingleThreadTaskEnvironment* task_environment)
  112. : task_enviornment_(task_environment) {
  113. data_parser_ = std::make_unique<ash::quick_pair::FastPairDataParser>(
  114. fast_pair_data_parser_.InitWithNewPipeAndPassReceiver());
  115. data_parser_remote_.Bind(std::move(fast_pair_data_parser_),
  116. task_enviornment_->GetMainThreadTaskRunner());
  117. }
  118. ~FakeQuickPairProcessManager() override = default;
  119. std::unique_ptr<ProcessReference> GetProcessReference(
  120. ProcessStoppedCallback on_process_stopped_callback) override {
  121. on_process_stopped_callback_ = std::move(on_process_stopped_callback);
  122. if (process_stopped_) {
  123. std::move(on_process_stopped_callback_)
  124. .Run(ash::quick_pair::QuickPairProcessManager::ShutdownReason::
  125. kFastPairDataParserMojoPipeDisconnection);
  126. }
  127. return std::make_unique<
  128. ash::quick_pair::QuickPairProcessManagerImpl::ProcessReferenceImpl>(
  129. data_parser_remote_, base::DoNothing());
  130. }
  131. void SetProcessStopped(bool process_stopped) {
  132. process_stopped_ = process_stopped;
  133. }
  134. private:
  135. bool process_stopped_ = false;
  136. mojo::SharedRemote<ash::quick_pair::mojom::FastPairDataParser>
  137. data_parser_remote_;
  138. mojo::PendingRemote<ash::quick_pair::mojom::FastPairDataParser>
  139. fast_pair_data_parser_;
  140. std::unique_ptr<ash::quick_pair::FastPairDataParser> data_parser_;
  141. base::test::SingleThreadTaskEnvironment* task_enviornment_;
  142. ProcessStoppedCallback on_process_stopped_callback_;
  143. };
  144. } // namespace
  145. namespace ash {
  146. namespace quick_pair {
  147. class MessageStreamTest : public testing::Test, public MessageStream::Observer {
  148. public:
  149. void SetUp() override {
  150. process_manager_ =
  151. std::make_unique<FakeQuickPairProcessManager>(&task_enviornment_);
  152. quick_pair_process::SetProcessManager(process_manager_.get());
  153. fake_process_manager_ =
  154. static_cast<FakeQuickPairProcessManager*>(process_manager_.get());
  155. message_stream_ =
  156. std::make_unique<MessageStream>(kTestDeviceAddress, fake_socket_.get());
  157. }
  158. void AddObserver() { message_stream_->AddObserver(this); }
  159. MockQuickPairProcessManager* mock_process_manager() {
  160. return static_cast<MockQuickPairProcessManager*>(process_manager_.get());
  161. }
  162. void SetSuccessMessageStreamMessage(const std::vector<uint8_t>& bytes) {
  163. fake_socket_->SetIOBufferFromBytes(bytes);
  164. }
  165. void TriggerReceiveSuccessCallback() {
  166. fake_socket_->TriggerReceiveCallback();
  167. }
  168. void OnModelIdMessage(const std::string& device_address,
  169. const std::string& model_id) override {
  170. model_id_ = std::move(model_id);
  171. }
  172. void OnMessageStreamDestroyed(const std::string& device_address) override {
  173. on_destroyed_ = true;
  174. }
  175. void CleanUpMemory() { message_stream_.reset(); }
  176. void DisconnectSocket() {
  177. fake_socket_->SetErrorReason(
  178. device::BluetoothSocket::ErrorReason::kDisconnected);
  179. }
  180. void SetEmptyBuffer() { fake_socket_->SetEmptyBuffer(); }
  181. void OnDisconnected(const std::string& device_address) override {
  182. on_socket_disconnected_ = true;
  183. }
  184. void OnBleAddressUpdateMessage(const std::string& device_address,
  185. const std::string& ble_address) override {
  186. ble_address_ = std::move(ble_address);
  187. }
  188. void OnBatteryUpdateMessage(
  189. const std::string& device_address,
  190. const mojom::BatteryUpdatePtr& battery_update) override {
  191. battery_update_ = true;
  192. }
  193. void OnRemainingBatteryTimeMessage(const std::string& device_address,
  194. uint16_t remaining_battery_time) override {
  195. remaining_battery_time_ = remaining_battery_time;
  196. }
  197. void OnEnableSilenceModeMessage(const std::string& device_address,
  198. bool enable_silence_mode) override {
  199. enable_silence_mode_ = enable_silence_mode;
  200. }
  201. void OnCompanionAppLogBufferFullMessage(
  202. const std::string& device_address) override {
  203. log_buffer_full_ = true;
  204. }
  205. void OnActiveComponentsMessage(const std::string& device_address,
  206. uint8_t active_components_byte) override {
  207. active_components_byte_ = active_components_byte;
  208. }
  209. void OnRingDeviceMessage(const std::string& device_address,
  210. const mojom::RingDevicePtr& ring_device) override {
  211. ring_device_ = true;
  212. }
  213. void OnAcknowledgementMessage(
  214. const std::string& device_address,
  215. const mojom::AcknowledgementMessagePtr& acknowledgement) override {
  216. acknowledgement_ = true;
  217. }
  218. void OnAndroidSdkVersionMessage(const std::string& device_address,
  219. uint8_t sdk_version) override {
  220. sdk_version_ = sdk_version;
  221. }
  222. base::HistogramTester& histogram_tester() { return histogram_tester_; }
  223. protected:
  224. base::HistogramTester histogram_tester_;
  225. scoped_refptr<FakeBluetoothSocket> fake_socket_ =
  226. base::MakeRefCounted<FakeBluetoothSocket>();
  227. std::unique_ptr<MessageStream> message_stream_;
  228. std::string model_id_;
  229. std::string ble_address_;
  230. base::test::SingleThreadTaskEnvironment task_enviornment_;
  231. std::unique_ptr<QuickPairProcessManager> process_manager_;
  232. mojo::SharedRemote<mojom::FastPairDataParser> data_parser_remote_;
  233. mojo::PendingRemote<mojom::FastPairDataParser> fast_pair_data_parser_;
  234. std::unique_ptr<FastPairDataParser> data_parser_;
  235. FakeQuickPairProcessManager* fake_process_manager_;
  236. bool battery_update_ = false;
  237. uint16_t remaining_battery_time_ = 0;
  238. bool enable_silence_mode_ = false;
  239. bool on_destroyed_ = false;
  240. bool on_socket_disconnected_ = false;
  241. bool log_buffer_full_ = false;
  242. uint8_t active_components_byte_ = 0x0F;
  243. bool ring_device_ = false;
  244. bool acknowledgement_ = false;
  245. uint8_t sdk_version_ = 0;
  246. };
  247. TEST_F(MessageStreamTest, ReceiveMessages_Observation_SuccessfulMessage) {
  248. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 0);
  249. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 0);
  250. EXPECT_TRUE(model_id_.empty());
  251. EXPECT_TRUE(message_stream_->messages().empty());
  252. AddObserver();
  253. SetSuccessMessageStreamMessage(kModelIdBytes);
  254. TriggerReceiveSuccessCallback();
  255. base::RunLoop().RunUntilIdle();
  256. EXPECT_EQ(model_id_, kModelIdString);
  257. EXPECT_FALSE(message_stream_->messages().empty());
  258. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 1);
  259. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 0);
  260. }
  261. TEST_F(MessageStreamTest, ReceiveMessages_Observation_NullMessage) {
  262. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 0);
  263. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 0);
  264. EXPECT_TRUE(model_id_.empty());
  265. EXPECT_TRUE(message_stream_->messages().empty());
  266. AddObserver();
  267. SetSuccessMessageStreamMessage(kInvalidBytes);
  268. TriggerReceiveSuccessCallback();
  269. base::RunLoop().RunUntilIdle();
  270. EXPECT_TRUE(message_stream_->messages().empty());
  271. EXPECT_TRUE(model_id_.empty());
  272. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 1);
  273. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 0);
  274. }
  275. TEST_F(MessageStreamTest, ReceiveMessages_GetMessages) {
  276. EXPECT_TRUE(model_id_.empty());
  277. EXPECT_TRUE(message_stream_->messages().empty());
  278. SetSuccessMessageStreamMessage(kModelIdBytes);
  279. TriggerReceiveSuccessCallback();
  280. base::RunLoop().RunUntilIdle();
  281. EXPECT_FALSE(message_stream_->messages().empty());
  282. EXPECT_EQ(message_stream_->messages()[0]->get_model_id(), kModelIdString);
  283. }
  284. TEST_F(MessageStreamTest, ReceiveMessages_CleanUp) {
  285. EXPECT_TRUE(model_id_.empty());
  286. EXPECT_TRUE(message_stream_->messages().empty());
  287. AddObserver();
  288. SetSuccessMessageStreamMessage(kModelIdBytes);
  289. TriggerReceiveSuccessCallback();
  290. base::RunLoop().RunUntilIdle();
  291. EXPECT_FALSE(message_stream_->messages().empty());
  292. EXPECT_FALSE(on_destroyed_);
  293. CleanUpMemory();
  294. EXPECT_TRUE(on_destroyed_);
  295. }
  296. TEST_F(MessageStreamTest, ReceiveMessages_SocketDisconnect) {
  297. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 0);
  298. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 0);
  299. EXPECT_FALSE(on_socket_disconnected_);
  300. EXPECT_TRUE(message_stream_->messages().empty());
  301. DisconnectSocket();
  302. AddObserver();
  303. TriggerReceiveSuccessCallback();
  304. base::RunLoop().RunUntilIdle();
  305. EXPECT_TRUE(message_stream_->messages().empty());
  306. EXPECT_TRUE(on_socket_disconnected_);
  307. histogram_tester().ExpectTotalCount(kMessageStreamReceiveResultMetric, 1);
  308. histogram_tester().ExpectTotalCount(kMessageStreamReceiveErrorMetric, 1);
  309. }
  310. TEST_F(MessageStreamTest,
  311. ReceiveMessages_DisconnectCallback_SocketAlreadyDisconnected) {
  312. EXPECT_FALSE(on_socket_disconnected_);
  313. EXPECT_TRUE(message_stream_->messages().empty());
  314. DisconnectSocket();
  315. AddObserver();
  316. TriggerReceiveSuccessCallback();
  317. base::RunLoop().RunUntilIdle();
  318. EXPECT_TRUE(message_stream_->messages().empty());
  319. EXPECT_TRUE(on_socket_disconnected_);
  320. base::MockCallback<base::OnceClosure> callback;
  321. EXPECT_CALL(callback, Run).Times(1);
  322. message_stream_->Disconnect(callback.Get());
  323. }
  324. TEST_F(MessageStreamTest, ReceiveMessages_FailureAfterMaxRetries) {
  325. EXPECT_FALSE(on_socket_disconnected_);
  326. EXPECT_TRUE(message_stream_->messages().empty());
  327. AddObserver();
  328. for (int i = 0; i < kMaxRetryCount; ++i) {
  329. TriggerReceiveSuccessCallback();
  330. base::RunLoop().RunUntilIdle();
  331. }
  332. EXPECT_TRUE(message_stream_->messages().empty());
  333. EXPECT_TRUE(on_socket_disconnected_);
  334. }
  335. TEST_F(MessageStreamTest,
  336. ReceiveMessages_Observation_SuccessfulMultipleMessages) {
  337. EXPECT_TRUE(model_id_.empty());
  338. EXPECT_TRUE(ble_address_.empty());
  339. EXPECT_TRUE(message_stream_->messages().empty());
  340. AddObserver();
  341. SetSuccessMessageStreamMessage(kModelIdBleAddressBytes);
  342. TriggerReceiveSuccessCallback();
  343. base::RunLoop().RunUntilIdle();
  344. EXPECT_FALSE(message_stream_->messages().empty());
  345. EXPECT_EQ(model_id_, kModelIdString);
  346. EXPECT_EQ(ble_address_, kBleAddressString);
  347. }
  348. TEST_F(MessageStreamTest, ReceiveMessages_GetMultipleMessages) {
  349. EXPECT_TRUE(model_id_.empty());
  350. EXPECT_TRUE(ble_address_.empty());
  351. EXPECT_TRUE(message_stream_->messages().empty());
  352. SetSuccessMessageStreamMessage(kModelIdBleAddressBytes);
  353. TriggerReceiveSuccessCallback();
  354. base::RunLoop().RunUntilIdle();
  355. EXPECT_FALSE(message_stream_->messages().empty());
  356. EXPECT_EQ(message_stream_->messages()[0]->get_model_id(), kModelIdString);
  357. EXPECT_EQ(message_stream_->messages()[1]->get_ble_address_update(),
  358. kBleAddressString);
  359. }
  360. TEST_F(MessageStreamTest, ReceiveMessages_BatteryUpdate) {
  361. EXPECT_FALSE(battery_update_);
  362. EXPECT_TRUE(message_stream_->messages().empty());
  363. AddObserver();
  364. SetSuccessMessageStreamMessage(kBatteryUpdateBytes);
  365. TriggerReceiveSuccessCallback();
  366. base::RunLoop().RunUntilIdle();
  367. EXPECT_FALSE(message_stream_->messages().empty());
  368. EXPECT_TRUE(battery_update_);
  369. }
  370. TEST_F(MessageStreamTest, ReceiveMessages_RemainingBatteryTime) {
  371. EXPECT_EQ(remaining_battery_time_, 0);
  372. EXPECT_TRUE(message_stream_->messages().empty());
  373. AddObserver();
  374. SetSuccessMessageStreamMessage(kRemainingBatteryTimeBytes);
  375. TriggerReceiveSuccessCallback();
  376. base::RunLoop().RunUntilIdle();
  377. EXPECT_FALSE(message_stream_->messages().empty());
  378. EXPECT_EQ(remaining_battery_time_, 271);
  379. }
  380. TEST_F(MessageStreamTest, ReceiveMessages_ActiveComponents) {
  381. EXPECT_EQ(active_components_byte_, 0x0F);
  382. EXPECT_TRUE(message_stream_->messages().empty());
  383. AddObserver();
  384. SetSuccessMessageStreamMessage(kActiveComponentBytes);
  385. TriggerReceiveSuccessCallback();
  386. base::RunLoop().RunUntilIdle();
  387. EXPECT_FALSE(message_stream_->messages().empty());
  388. EXPECT_EQ(active_components_byte_, 0x03);
  389. }
  390. TEST_F(MessageStreamTest, ReceiveMessages_SdkVersion) {
  391. EXPECT_EQ(sdk_version_, 0);
  392. EXPECT_TRUE(message_stream_->messages().empty());
  393. AddObserver();
  394. SetSuccessMessageStreamMessage(kPlatformBytes);
  395. TriggerReceiveSuccessCallback();
  396. base::RunLoop().RunUntilIdle();
  397. EXPECT_FALSE(message_stream_->messages().empty());
  398. EXPECT_EQ(sdk_version_, 28);
  399. }
  400. TEST_F(MessageStreamTest, ReceiveMessages_RingDevice) {
  401. EXPECT_FALSE(ring_device_);
  402. EXPECT_TRUE(message_stream_->messages().empty());
  403. AddObserver();
  404. SetSuccessMessageStreamMessage(kRingDeviceBytes);
  405. TriggerReceiveSuccessCallback();
  406. base::RunLoop().RunUntilIdle();
  407. EXPECT_FALSE(message_stream_->messages().empty());
  408. EXPECT_TRUE(ring_device_);
  409. }
  410. TEST_F(MessageStreamTest, ReceiveMessages_EnableSilenceMode) {
  411. EXPECT_FALSE(enable_silence_mode_);
  412. EXPECT_TRUE(message_stream_->messages().empty());
  413. AddObserver();
  414. SetSuccessMessageStreamMessage(kEnableSilenceModeBytes);
  415. TriggerReceiveSuccessCallback();
  416. base::RunLoop().RunUntilIdle();
  417. EXPECT_FALSE(message_stream_->messages().empty());
  418. EXPECT_TRUE(enable_silence_mode_);
  419. }
  420. TEST_F(MessageStreamTest, ReceiveMessages_CompanionAppLogBuffer) {
  421. EXPECT_FALSE(log_buffer_full_);
  422. EXPECT_TRUE(message_stream_->messages().empty());
  423. AddObserver();
  424. SetSuccessMessageStreamMessage(kCompanionAppLogBufferFullBytes);
  425. TriggerReceiveSuccessCallback();
  426. base::RunLoop().RunUntilIdle();
  427. EXPECT_FALSE(message_stream_->messages().empty());
  428. EXPECT_TRUE(log_buffer_full_);
  429. }
  430. TEST_F(MessageStreamTest, ReceiveMessages_Nak) {
  431. EXPECT_FALSE(acknowledgement_);
  432. EXPECT_TRUE(message_stream_->messages().empty());
  433. AddObserver();
  434. SetSuccessMessageStreamMessage(kNakBytes);
  435. TriggerReceiveSuccessCallback();
  436. base::RunLoop().RunUntilIdle();
  437. EXPECT_FALSE(message_stream_->messages().empty());
  438. EXPECT_TRUE(acknowledgement_);
  439. }
  440. TEST_F(MessageStreamTest, ReceiveMessages_EmptyBuffer_SuccessReceive) {
  441. EXPECT_TRUE(message_stream_->messages().empty());
  442. SetEmptyBuffer();
  443. SetSuccessMessageStreamMessage(kModelIdBytes);
  444. TriggerReceiveSuccessCallback();
  445. base::RunLoop().RunUntilIdle();
  446. EXPECT_TRUE(message_stream_->messages().empty());
  447. TriggerReceiveSuccessCallback();
  448. base::RunLoop().RunUntilIdle();
  449. EXPECT_FALSE(message_stream_->messages().empty());
  450. }
  451. TEST_F(MessageStreamTest, ReceiveMessages_EmptyBuffer_ErrorReceive) {
  452. EXPECT_TRUE(message_stream_->messages().empty());
  453. SetEmptyBuffer();
  454. TriggerReceiveSuccessCallback();
  455. base::RunLoop().RunUntilIdle();
  456. EXPECT_TRUE(message_stream_->messages().empty());
  457. TriggerReceiveSuccessCallback();
  458. base::RunLoop().RunUntilIdle();
  459. EXPECT_TRUE(message_stream_->messages().empty());
  460. }
  461. TEST_F(MessageStreamTest, ReceiveMessages_BufferFull) {
  462. EXPECT_TRUE(model_id_.empty());
  463. EXPECT_TRUE(ble_address_.empty());
  464. AddObserver();
  465. for (int i = 0; i < kMessageStorageCapacity + 1; i++) {
  466. SetSuccessMessageStreamMessage(kModelIdBytes);
  467. TriggerReceiveSuccessCallback();
  468. base::RunLoop().RunUntilIdle();
  469. }
  470. EXPECT_EQ(static_cast<int>(message_stream_->messages().size()),
  471. kMessageStorageCapacity);
  472. }
  473. TEST_F(MessageStreamTest, UtilityProcessStopped_RetrySuccess) {
  474. EXPECT_TRUE(message_stream_->messages().empty());
  475. fake_process_manager_->SetProcessStopped(true);
  476. SetSuccessMessageStreamMessage(kModelIdBytes);
  477. TriggerReceiveSuccessCallback();
  478. base::RunLoop().RunUntilIdle();
  479. EXPECT_FALSE(message_stream_->messages().empty());
  480. }
  481. } // namespace quick_pair
  482. } // namespace ash