fast_pair_data_parser_unittest.cc 50 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237
  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/services/quick_pair/fast_pair_data_parser.h"
  5. #include <stddef.h>
  6. #include <iterator>
  7. #include "ash/quick_pair/common/fast_pair/fast_pair_service_data_creator.h"
  8. #include "ash/services/quick_pair/public/cpp/decrypted_passkey.h"
  9. #include "ash/services/quick_pair/public/cpp/decrypted_response.h"
  10. #include "ash/services/quick_pair/public/cpp/fast_pair_message_type.h"
  11. #include "ash/services/quick_pair/public/cpp/not_discoverable_advertisement.h"
  12. #include "ash/services/quick_pair/public/mojom/fast_pair_data_parser.mojom.h"
  13. #include "base/run_loop.h"
  14. #include "base/strings/string_number_conversions.h"
  15. #include "base/test/bind.h"
  16. #include "base/test/task_environment.h"
  17. #include "mojo/public/cpp/bindings/remote.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. #include "third_party/abseil-cpp/absl/types/optional.h"
  20. #include "third_party/boringssl/src/include/openssl/aes.h"
  21. namespace {
  22. constexpr int kNotDiscoverableAdvHeader = 0b00000110;
  23. constexpr int kAccountKeyFilterHeader = 0b01100000;
  24. constexpr int kAccountKeyFilterNoNotificationHeader = 0b01100010;
  25. constexpr int kSaltHeader = 0b00010001;
  26. const std::vector<uint8_t> kSaltBytes = {0x01};
  27. const std::vector<uint8_t> kInvalidSaltBytes = {0x01, 0x02};
  28. const std::vector<uint8_t> kDeviceAddressBytes = {17, 18, 19, 20, 21, 22};
  29. constexpr int kBatteryHeader = 0b00110011;
  30. constexpr int kBatterHeaderNoNotification = 0b00110100;
  31. const std::string kModelId = "112233";
  32. const std::string kAccountKeyFilter = "112233445566";
  33. const std::string kSalt = "01";
  34. const std::string kInvalidSalt = "01020404050607";
  35. const std::string kBattery = "01048F";
  36. const std::string kDeviceAddress = "11:12:13:14:15:16";
  37. std::vector<uint8_t> aes_key_bytes = {0xA0, 0xBA, 0xF0, 0xBB, 0x95, 0x1F,
  38. 0xF7, 0xB6, 0xCF, 0x5E, 0x3F, 0x45,
  39. 0x61, 0xC3, 0x32, 0x1D};
  40. std::vector<uint8_t> EncryptBytes(const std::vector<uint8_t>& bytes) {
  41. AES_KEY aes_key;
  42. AES_set_encrypt_key(aes_key_bytes.data(), aes_key_bytes.size() * 8, &aes_key);
  43. uint8_t encrypted_bytes[16];
  44. AES_encrypt(bytes.data(), encrypted_bytes, &aes_key);
  45. return std::vector<uint8_t>(std::begin(encrypted_bytes),
  46. std::end(encrypted_bytes));
  47. }
  48. } // namespace
  49. namespace ash {
  50. namespace quick_pair {
  51. class FastPairDataParserTest : public testing::Test {
  52. public:
  53. void SetUp() override {
  54. data_parser_ = std::make_unique<FastPairDataParser>(
  55. remote_.BindNewPipeAndPassReceiver());
  56. }
  57. protected:
  58. base::test::TaskEnvironment task_environment_;
  59. mojo::Remote<mojom::FastPairDataParser> remote_;
  60. std::unique_ptr<FastPairDataParser> data_parser_;
  61. };
  62. TEST_F(FastPairDataParserTest, DecryptResponseUnsuccessfully) {
  63. std::vector<uint8_t> response_bytes = {/*message_type=*/0x02,
  64. /*address_bytes=*/0x02,
  65. 0x03,
  66. 0x04,
  67. 0x05,
  68. 0x06,
  69. 0x07,
  70. /*salt=*/0x08,
  71. 0x09,
  72. 0x0A,
  73. 0x0B,
  74. 0x0C,
  75. 0x0D,
  76. 0x0E,
  77. 0x0F,
  78. 0x00};
  79. std::vector<uint8_t> encrypted_bytes = EncryptBytes(response_bytes);
  80. base::RunLoop run_loop;
  81. auto callback = base::BindLambdaForTesting(
  82. [&run_loop](const absl::optional<DecryptedResponse>& response) {
  83. EXPECT_FALSE(response.has_value());
  84. run_loop.Quit();
  85. });
  86. data_parser_->ParseDecryptedResponse(aes_key_bytes, encrypted_bytes,
  87. std::move(callback));
  88. run_loop.Run();
  89. }
  90. TEST_F(FastPairDataParserTest, DecryptResponseSuccessfully) {
  91. std::vector<uint8_t> response_bytes;
  92. // Message type.
  93. uint8_t message_type = 0x01;
  94. response_bytes.push_back(message_type);
  95. // Address bytes.
  96. std::array<uint8_t, 6> address_bytes = {0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
  97. std::copy(address_bytes.begin(), address_bytes.end(),
  98. std::back_inserter(response_bytes));
  99. // Random salt
  100. std::array<uint8_t, 9> salt = {0x08, 0x09, 0x0A, 0x0B, 0x0C,
  101. 0x0D, 0x0E, 0x0F, 0x00};
  102. std::copy(salt.begin(), salt.end(), std::back_inserter(response_bytes));
  103. std::vector<uint8_t> encrypted_bytes = EncryptBytes(response_bytes);
  104. base::RunLoop run_loop;
  105. auto callback = base::BindLambdaForTesting(
  106. [&run_loop, &address_bytes,
  107. &salt](const absl::optional<DecryptedResponse>& response) {
  108. EXPECT_TRUE(response.has_value());
  109. EXPECT_EQ(response->message_type,
  110. FastPairMessageType::kKeyBasedPairingResponse);
  111. EXPECT_EQ(response->address_bytes, address_bytes);
  112. EXPECT_EQ(response->salt, salt);
  113. run_loop.Quit();
  114. });
  115. data_parser_->ParseDecryptedResponse(aes_key_bytes, encrypted_bytes,
  116. std::move(callback));
  117. run_loop.Run();
  118. }
  119. TEST_F(FastPairDataParserTest, DecryptPasskeyUnsuccessfully) {
  120. std::vector<uint8_t> passkey_bytes = {/*message_type=*/0x04,
  121. /*passkey=*/0x02,
  122. 0x03,
  123. 0x04,
  124. /*salt=*/0x05,
  125. 0x06,
  126. 0x07,
  127. 0x08,
  128. 0x09,
  129. 0x0A,
  130. 0x0B,
  131. 0x0C,
  132. 0x0D,
  133. 0x0E,
  134. 0x0F,
  135. 0x0E};
  136. std::vector<uint8_t> encrypted_bytes = EncryptBytes(passkey_bytes);
  137. base::RunLoop run_loop;
  138. auto callback = base::BindLambdaForTesting(
  139. [&run_loop](const absl::optional<DecryptedPasskey>& passkey) {
  140. EXPECT_FALSE(passkey.has_value());
  141. run_loop.Quit();
  142. });
  143. data_parser_->ParseDecryptedPasskey(aes_key_bytes, encrypted_bytes,
  144. std::move(callback));
  145. run_loop.Run();
  146. }
  147. TEST_F(FastPairDataParserTest, DecryptSeekerPasskeySuccessfully) {
  148. std::vector<uint8_t> passkey_bytes;
  149. // Message type.
  150. uint8_t message_type = 0x02;
  151. passkey_bytes.push_back(message_type);
  152. // Passkey bytes.
  153. uint32_t passkey = 5;
  154. passkey_bytes.push_back(passkey >> 16);
  155. passkey_bytes.push_back(passkey >> 8);
  156. passkey_bytes.push_back(passkey);
  157. // Random salt
  158. std::array<uint8_t, 12> salt = {0x08, 0x09, 0x0A, 0x08, 0x09, 0x0E,
  159. 0x0A, 0x0C, 0x0D, 0x0E, 0x05, 0x02};
  160. std::copy(salt.begin(), salt.end(), std::back_inserter(passkey_bytes));
  161. std::vector<uint8_t> encrypted_bytes = EncryptBytes(passkey_bytes);
  162. base::RunLoop run_loop;
  163. auto callback = base::BindLambdaForTesting(
  164. [&run_loop, &passkey,
  165. &salt](const absl::optional<DecryptedPasskey>& decrypted_passkey) {
  166. EXPECT_TRUE(decrypted_passkey.has_value());
  167. EXPECT_EQ(decrypted_passkey->message_type,
  168. FastPairMessageType::kSeekersPasskey);
  169. EXPECT_EQ(decrypted_passkey->passkey, passkey);
  170. EXPECT_EQ(decrypted_passkey->salt, salt);
  171. run_loop.Quit();
  172. });
  173. data_parser_->ParseDecryptedPasskey(aes_key_bytes, encrypted_bytes,
  174. std::move(callback));
  175. run_loop.Run();
  176. }
  177. TEST_F(FastPairDataParserTest, DecryptProviderPasskeySuccessfully) {
  178. std::vector<uint8_t> passkey_bytes;
  179. // Message type.
  180. uint8_t message_type = 0x03;
  181. passkey_bytes.push_back(message_type);
  182. // Passkey bytes.
  183. uint32_t passkey = 5;
  184. passkey_bytes.push_back(passkey >> 16);
  185. passkey_bytes.push_back(passkey >> 8);
  186. passkey_bytes.push_back(passkey);
  187. // Random salt
  188. std::array<uint8_t, 12> salt = {0x08, 0x09, 0x0A, 0x08, 0x09, 0x0E,
  189. 0x0A, 0x0C, 0x0D, 0x0E, 0x05, 0x02};
  190. std::copy(salt.begin(), salt.end(), std::back_inserter(passkey_bytes));
  191. std::vector<uint8_t> encrypted_bytes = EncryptBytes(passkey_bytes);
  192. base::RunLoop run_loop;
  193. auto callback = base::BindLambdaForTesting(
  194. [&run_loop, &passkey,
  195. &salt](const absl::optional<DecryptedPasskey>& decrypted_passkey) {
  196. EXPECT_TRUE(decrypted_passkey.has_value());
  197. EXPECT_EQ(decrypted_passkey->message_type,
  198. FastPairMessageType::kProvidersPasskey);
  199. EXPECT_EQ(decrypted_passkey->passkey, passkey);
  200. EXPECT_EQ(decrypted_passkey->salt, salt);
  201. run_loop.Quit();
  202. });
  203. data_parser_->ParseDecryptedPasskey(aes_key_bytes, encrypted_bytes,
  204. std::move(callback));
  205. run_loop.Run();
  206. }
  207. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_Empty) {
  208. base::RunLoop run_loop;
  209. auto callback = base::BindLambdaForTesting(
  210. [&run_loop](
  211. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  212. EXPECT_FALSE(advertisement.has_value());
  213. run_loop.Quit();
  214. });
  215. data_parser_->ParseNotDiscoverableAdvertisement(
  216. std::vector<uint8_t>(), kDeviceAddress, std::move(callback));
  217. run_loop.Run();
  218. }
  219. TEST_F(FastPairDataParserTest,
  220. ParseNotDiscoverableAdvertisement_NoApplicibleData) {
  221. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  222. .SetHeader(kNotDiscoverableAdvHeader)
  223. .Build()
  224. ->CreateServiceData();
  225. base::RunLoop run_loop;
  226. auto callback = base::BindLambdaForTesting(
  227. [&run_loop](
  228. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  229. EXPECT_FALSE(advertisement.has_value());
  230. run_loop.Quit();
  231. });
  232. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  233. std::move(callback));
  234. run_loop.Run();
  235. }
  236. TEST_F(FastPairDataParserTest,
  237. ParseNotDiscoverableAdvertisement_AccountKeyFilter) {
  238. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  239. .SetHeader(kNotDiscoverableAdvHeader)
  240. .SetModelId(kModelId)
  241. .AddExtraFieldHeader(kAccountKeyFilterHeader)
  242. .AddExtraField(kAccountKeyFilter)
  243. .AddExtraFieldHeader(kSaltHeader)
  244. .AddExtraField(kSalt)
  245. .Build()
  246. ->CreateServiceData();
  247. base::RunLoop run_loop;
  248. auto callback = base::BindLambdaForTesting(
  249. [&run_loop](
  250. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  251. EXPECT_TRUE(advertisement.has_value());
  252. EXPECT_EQ(kAccountKeyFilter,
  253. base::HexEncode(advertisement->account_key_filter));
  254. EXPECT_EQ(kSaltBytes, advertisement->salt);
  255. EXPECT_TRUE(advertisement->show_ui);
  256. EXPECT_FALSE(advertisement->battery_notification.has_value());
  257. run_loop.Quit();
  258. });
  259. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  260. std::move(callback));
  261. run_loop.Run();
  262. }
  263. TEST_F(FastPairDataParserTest,
  264. ParseNotDiscoverableAdvertisement_AccountKeyFilterNoNotification) {
  265. std::vector<uint8_t> bytes =
  266. FastPairServiceDataCreator::Builder()
  267. .SetHeader(kNotDiscoverableAdvHeader)
  268. .SetModelId(kModelId)
  269. .AddExtraFieldHeader(kAccountKeyFilterNoNotificationHeader)
  270. .AddExtraField(kAccountKeyFilter)
  271. .AddExtraFieldHeader(kSaltHeader)
  272. .AddExtraField(kSalt)
  273. .Build()
  274. ->CreateServiceData();
  275. base::RunLoop run_loop;
  276. auto callback = base::BindLambdaForTesting(
  277. [&run_loop](
  278. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  279. EXPECT_TRUE(advertisement.has_value());
  280. EXPECT_EQ(kAccountKeyFilter,
  281. base::HexEncode(advertisement->account_key_filter));
  282. EXPECT_EQ(kSaltBytes, advertisement->salt);
  283. EXPECT_FALSE(advertisement->show_ui);
  284. EXPECT_FALSE(advertisement->battery_notification.has_value());
  285. run_loop.Quit();
  286. });
  287. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  288. std::move(callback));
  289. run_loop.Run();
  290. }
  291. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_WrongVersion) {
  292. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  293. .SetHeader(0b00100000)
  294. .Build()
  295. ->CreateServiceData();
  296. base::RunLoop run_loop;
  297. auto callback = base::BindLambdaForTesting(
  298. [&run_loop](
  299. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  300. EXPECT_FALSE(advertisement.has_value());
  301. run_loop.Quit();
  302. });
  303. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  304. std::move(callback));
  305. run_loop.Run();
  306. }
  307. TEST_F(FastPairDataParserTest,
  308. ParseNotDiscoverableAdvertisement_ZeroLengthExtraField) {
  309. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  310. .SetHeader(kNotDiscoverableAdvHeader)
  311. .SetModelId(kModelId)
  312. .AddExtraFieldHeader(kAccountKeyFilterHeader)
  313. .AddExtraField("")
  314. .AddExtraFieldHeader(kSaltHeader)
  315. .AddExtraField(kSalt)
  316. .Build()
  317. ->CreateServiceData();
  318. base::RunLoop run_loop;
  319. auto callback = base::BindLambdaForTesting(
  320. [&run_loop](
  321. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  322. EXPECT_FALSE(advertisement.has_value());
  323. run_loop.Quit();
  324. });
  325. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  326. std::move(callback));
  327. run_loop.Run();
  328. }
  329. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_WrongType) {
  330. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  331. .SetHeader(kNotDiscoverableAdvHeader)
  332. .SetModelId(kModelId)
  333. .AddExtraFieldHeader(0b01100001)
  334. .AddExtraField(kAccountKeyFilter)
  335. .AddExtraFieldHeader(kSaltHeader)
  336. .AddExtraField(kSalt)
  337. .Build()
  338. ->CreateServiceData();
  339. base::RunLoop run_loop;
  340. auto callback = base::BindLambdaForTesting(
  341. [&run_loop](
  342. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  343. EXPECT_FALSE(advertisement.has_value());
  344. run_loop.Quit();
  345. });
  346. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  347. std::move(callback));
  348. run_loop.Run();
  349. }
  350. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_SaltTooLarge) {
  351. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  352. .SetHeader(kNotDiscoverableAdvHeader)
  353. .SetModelId(kModelId)
  354. .AddExtraFieldHeader(0b01100001)
  355. .AddExtraField(kAccountKeyFilter)
  356. .AddExtraFieldHeader(kSaltHeader)
  357. .AddExtraField(kInvalidSalt)
  358. .Build()
  359. ->CreateServiceData();
  360. base::RunLoop run_loop;
  361. auto callback = base::BindLambdaForTesting(
  362. [&run_loop](
  363. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  364. EXPECT_FALSE(advertisement.has_value());
  365. run_loop.Quit();
  366. });
  367. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  368. std::move(callback));
  369. run_loop.Run();
  370. }
  371. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_Battery) {
  372. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  373. .SetHeader(kNotDiscoverableAdvHeader)
  374. .SetModelId(kModelId)
  375. .AddExtraFieldHeader(kAccountKeyFilterHeader)
  376. .AddExtraField(kAccountKeyFilter)
  377. .AddExtraFieldHeader(kSaltHeader)
  378. .AddExtraField(kSalt)
  379. .AddExtraFieldHeader(kBatteryHeader)
  380. .AddExtraField(kBattery)
  381. .Build()
  382. ->CreateServiceData();
  383. base::RunLoop run_loop;
  384. auto callback = base::BindLambdaForTesting(
  385. [&run_loop](
  386. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  387. EXPECT_TRUE(advertisement.has_value());
  388. EXPECT_EQ(kAccountKeyFilter,
  389. base::HexEncode(advertisement->account_key_filter));
  390. EXPECT_EQ(kSaltBytes, advertisement->salt);
  391. EXPECT_TRUE(advertisement->show_ui);
  392. EXPECT_TRUE(advertisement->battery_notification.has_value());
  393. EXPECT_TRUE(advertisement->battery_notification->show_ui);
  394. EXPECT_FALSE(
  395. advertisement->battery_notification->left_bud_info.is_charging);
  396. EXPECT_EQ(advertisement->battery_notification->left_bud_info.percentage,
  397. 1);
  398. EXPECT_FALSE(
  399. advertisement->battery_notification->right_bud_info.is_charging);
  400. EXPECT_EQ(
  401. advertisement->battery_notification->right_bud_info.percentage, 4);
  402. EXPECT_TRUE(advertisement->battery_notification->case_info.is_charging);
  403. EXPECT_EQ(advertisement->battery_notification->case_info.percentage,
  404. 15);
  405. run_loop.Quit();
  406. });
  407. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  408. std::move(callback));
  409. run_loop.Run();
  410. }
  411. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_MissingSalt) {
  412. std::vector<uint8_t> bytes = FastPairServiceDataCreator::Builder()
  413. .SetHeader(kNotDiscoverableAdvHeader)
  414. .SetModelId(kModelId)
  415. .AddExtraFieldHeader(kAccountKeyFilterHeader)
  416. .AddExtraField(kAccountKeyFilter)
  417. .AddExtraFieldHeader(kBatteryHeader)
  418. .AddExtraField(kBattery)
  419. .Build()
  420. ->CreateServiceData();
  421. base::RunLoop run_loop;
  422. auto callback = base::BindLambdaForTesting(
  423. [&run_loop](
  424. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  425. EXPECT_TRUE(advertisement.has_value());
  426. EXPECT_EQ(kAccountKeyFilter,
  427. base::HexEncode(advertisement->account_key_filter));
  428. EXPECT_EQ(kDeviceAddressBytes, advertisement->salt);
  429. EXPECT_TRUE(advertisement->show_ui);
  430. EXPECT_TRUE(advertisement->battery_notification.has_value());
  431. EXPECT_TRUE(advertisement->battery_notification->show_ui);
  432. EXPECT_FALSE(
  433. advertisement->battery_notification->left_bud_info.is_charging);
  434. EXPECT_EQ(advertisement->battery_notification->left_bud_info.percentage,
  435. 1);
  436. EXPECT_FALSE(
  437. advertisement->battery_notification->right_bud_info.is_charging);
  438. EXPECT_EQ(
  439. advertisement->battery_notification->right_bud_info.percentage, 4);
  440. EXPECT_TRUE(advertisement->battery_notification->case_info.is_charging);
  441. EXPECT_EQ(advertisement->battery_notification->case_info.percentage,
  442. 15);
  443. run_loop.Quit();
  444. });
  445. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  446. std::move(callback));
  447. run_loop.Run();
  448. }
  449. TEST_F(FastPairDataParserTest, ParseNotDiscoverableAdvertisement_BatteryNoUi) {
  450. std::vector<uint8_t> bytes =
  451. FastPairServiceDataCreator::Builder()
  452. .SetHeader(kNotDiscoverableAdvHeader)
  453. .SetModelId(kModelId)
  454. .AddExtraFieldHeader(kAccountKeyFilterHeader)
  455. .AddExtraField(kAccountKeyFilter)
  456. .AddExtraFieldHeader(kSaltHeader)
  457. .AddExtraField(kSalt)
  458. .AddExtraFieldHeader(kBatterHeaderNoNotification)
  459. .AddExtraField(kBattery)
  460. .Build()
  461. ->CreateServiceData();
  462. base::RunLoop run_loop;
  463. auto callback = base::BindLambdaForTesting(
  464. [&run_loop](
  465. const absl::optional<NotDiscoverableAdvertisement>& advertisement) {
  466. EXPECT_TRUE(advertisement.has_value());
  467. EXPECT_EQ(kAccountKeyFilter,
  468. base::HexEncode(advertisement->account_key_filter));
  469. EXPECT_EQ(kSaltBytes, advertisement->salt);
  470. EXPECT_TRUE(advertisement->show_ui);
  471. EXPECT_TRUE(advertisement->battery_notification.has_value());
  472. EXPECT_FALSE(advertisement->battery_notification->show_ui);
  473. EXPECT_FALSE(
  474. advertisement->battery_notification->left_bud_info.is_charging);
  475. EXPECT_EQ(advertisement->battery_notification->left_bud_info.percentage,
  476. 1);
  477. EXPECT_FALSE(
  478. advertisement->battery_notification->right_bud_info.is_charging);
  479. EXPECT_EQ(
  480. advertisement->battery_notification->right_bud_info.percentage, 4);
  481. EXPECT_TRUE(advertisement->battery_notification->case_info.is_charging);
  482. EXPECT_EQ(advertisement->battery_notification->case_info.percentage,
  483. 15);
  484. run_loop.Quit();
  485. });
  486. data_parser_->ParseNotDiscoverableAdvertisement(bytes, kDeviceAddress,
  487. std::move(callback));
  488. run_loop.Run();
  489. }
  490. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_EnableSilenceMode) {
  491. std::vector<uint8_t> bytes = {/*mesage_group=*/0x01, /*mesage_code=*/0x01,
  492. /*additional_data_length=*/0x00, 0x00};
  493. base::RunLoop run_loop;
  494. auto callback = base::BindLambdaForTesting(
  495. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  496. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  497. EXPECT_TRUE(messages[0]->is_enable_silence_mode());
  498. EXPECT_TRUE(messages[0]->get_enable_silence_mode());
  499. run_loop.Quit();
  500. });
  501. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  502. run_loop.Run();
  503. }
  504. TEST_F(FastPairDataParserTest,
  505. ParseMessageStreamMessage_SilenceMode_AdditionalData) {
  506. std::vector<uint8_t> bytes = {/*mesage_group=*/0x01, /*mesage_code=*/0x01,
  507. /*additional_data_length=*/0x00, 0x01,
  508. /*additional_data=*/0x08};
  509. base::RunLoop run_loop;
  510. auto callback = base::BindLambdaForTesting(
  511. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  512. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  513. run_loop.Quit();
  514. });
  515. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  516. run_loop.Run();
  517. }
  518. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_DisableSilenceMode) {
  519. std::vector<uint8_t> bytes = {/*mesage_group=*/0x01, /*mesage_code=*/0x02,
  520. /*additional_data_length=*/0x00, 0x00};
  521. base::RunLoop run_loop;
  522. auto callback = base::BindLambdaForTesting(
  523. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  524. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  525. EXPECT_TRUE(messages[0]->is_enable_silence_mode());
  526. EXPECT_FALSE(messages[0]->get_enable_silence_mode());
  527. run_loop.Quit();
  528. });
  529. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  530. run_loop.Run();
  531. }
  532. TEST_F(FastPairDataParserTest,
  533. ParseMessageStreamMessage_BluetoothInvalidMessageCode) {
  534. std::vector<uint8_t> bytes = {/*mesage_group=*/0x01, /*mesage_code=*/0x03,
  535. /*additional_data_length=*/0x00, 0x00};
  536. base::RunLoop run_loop;
  537. auto callback = base::BindLambdaForTesting(
  538. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  539. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  540. run_loop.Quit();
  541. });
  542. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  543. run_loop.Run();
  544. }
  545. TEST_F(FastPairDataParserTest,
  546. ParseMessageStreamMessage_CompanionAppLogBufferFull) {
  547. std::vector<uint8_t> bytes = {/*mesage_group=*/0x02, /*mesage_code=*/0x01,
  548. /*additional_data_length=*/0x00, 0x00};
  549. base::RunLoop run_loop;
  550. auto callback = base::BindLambdaForTesting(
  551. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  552. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  553. EXPECT_TRUE(messages[0]->is_companion_app_log_buffer_full());
  554. EXPECT_TRUE(messages[0]->get_companion_app_log_buffer_full());
  555. run_loop.Quit();
  556. });
  557. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  558. run_loop.Run();
  559. }
  560. TEST_F(FastPairDataParserTest,
  561. ParseMessageStreamMessage_CompanionAppInvalidMessageCode) {
  562. std::vector<uint8_t> bytes = {/*mesage_group=*/0x02, /*mesage_code=*/0x02,
  563. /*additional_data_length=*/0x00, 0x00};
  564. base::RunLoop run_loop;
  565. auto callback = base::BindLambdaForTesting(
  566. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  567. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  568. run_loop.Quit();
  569. });
  570. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  571. run_loop.Run();
  572. }
  573. TEST_F(FastPairDataParserTest,
  574. ParseMessageStreamMessage_CompanionAppLogBufferFull_AdditionalData) {
  575. std::vector<uint8_t> bytes = {/*mesage_group=*/0x02, /*mesage_code=*/0x01,
  576. /*additional_data_length=*/0x00, 0x01,
  577. /*additional_data=*/0x08};
  578. base::RunLoop run_loop;
  579. auto callback = base::BindLambdaForTesting(
  580. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  581. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  582. run_loop.Quit();
  583. });
  584. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  585. run_loop.Run();
  586. }
  587. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_ModelId) {
  588. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  589. /*mesage_code=*/0x01,
  590. /*additional_data_length=*/0x00,
  591. 0x03,
  592. /*additional_data=*/0xAA,
  593. 0xBB,
  594. 0xCC};
  595. base::RunLoop run_loop;
  596. auto callback = base::BindLambdaForTesting(
  597. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  598. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  599. EXPECT_TRUE(messages[0]->is_model_id());
  600. EXPECT_EQ(messages[0]->get_model_id(), "AABBCC");
  601. run_loop.Quit();
  602. });
  603. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  604. run_loop.Run();
  605. }
  606. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_BleAddress) {
  607. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  608. /*mesage_code=*/0x02,
  609. /*additional_data_length=*/0x00,
  610. 0x06,
  611. /*additional_data=*/0xAA,
  612. 0xBB,
  613. 0xCC,
  614. 0xDD,
  615. 0xEE,
  616. 0xFF};
  617. base::RunLoop run_loop;
  618. auto callback = base::BindLambdaForTesting(
  619. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  620. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  621. EXPECT_TRUE(messages[0]->is_ble_address_update());
  622. EXPECT_EQ(messages[0]->get_ble_address_update(), "AA:BB:CC:DD:EE:FF");
  623. run_loop.Quit();
  624. });
  625. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  626. run_loop.Run();
  627. }
  628. TEST_F(FastPairDataParserTest,
  629. ParseMessageStreamMessage_WrongAdditionalDataSize) {
  630. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  631. /*mesage_code=*/0x02,
  632. /*additional_data_length=*/0x00,
  633. 0x08,
  634. /*additional_data=*/0xAA,
  635. 0xBB,
  636. 0xCC,
  637. 0xDD,
  638. 0xEE,
  639. 0xFF};
  640. base::RunLoop run_loop;
  641. auto callback = base::BindLambdaForTesting(
  642. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  643. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  644. run_loop.Quit();
  645. });
  646. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  647. run_loop.Run();
  648. }
  649. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_BatteryNotification) {
  650. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  651. /*mesage_code=*/0x03,
  652. /*additional_data_length=*/0x00,
  653. 0x03,
  654. /*additional_data=*/0x57,
  655. 0x41,
  656. 0x7F};
  657. base::RunLoop run_loop;
  658. auto callback = base::BindLambdaForTesting(
  659. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  660. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  661. EXPECT_TRUE(messages[0]->is_battery_update());
  662. EXPECT_EQ(messages[0]->get_battery_update()->left_bud_info->percentage,
  663. 87);
  664. EXPECT_EQ(messages[0]->get_battery_update()->right_bud_info->percentage,
  665. 65);
  666. EXPECT_EQ(messages[0]->get_battery_update()->case_info->percentage, -1);
  667. run_loop.Quit();
  668. });
  669. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  670. run_loop.Run();
  671. }
  672. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_RemainingBatteryTime) {
  673. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x04,
  674. /*additional_data_length=*/0x00, 0x01,
  675. /*additional_data=*/0xF0};
  676. base::RunLoop run_loop;
  677. auto callback = base::BindLambdaForTesting(
  678. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  679. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  680. EXPECT_TRUE(messages[0]->is_remaining_battery_time());
  681. EXPECT_EQ(messages[0]->get_remaining_battery_time(), 240);
  682. run_loop.Quit();
  683. });
  684. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  685. run_loop.Run();
  686. }
  687. TEST_F(FastPairDataParserTest,
  688. ParseMessageStreamMessage_RemainingBatteryTime_2BytesAdditionalData) {
  689. std::vector<uint8_t> bytes = {
  690. /*mesage_group=*/0x03, /*mesage_code=*/0x04,
  691. /*additional_data_length=*/0x00, 0x02,
  692. /*additional_data=*/0x01, 0x0F};
  693. base::RunLoop run_loop;
  694. auto callback = base::BindLambdaForTesting(
  695. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  696. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  697. EXPECT_TRUE(messages[0]->is_remaining_battery_time());
  698. EXPECT_EQ(messages[0]->get_remaining_battery_time(), 271);
  699. run_loop.Quit();
  700. });
  701. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  702. run_loop.Run();
  703. }
  704. TEST_F(FastPairDataParserTest,
  705. ParseMessageStreamMessage_DeviceInfoInvalidMessageCode) {
  706. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x09,
  707. /*additional_data_length=*/0x00, 0x00};
  708. base::RunLoop run_loop;
  709. auto callback = base::BindLambdaForTesting(
  710. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  711. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  712. run_loop.Quit();
  713. });
  714. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  715. run_loop.Run();
  716. }
  717. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_ModelIdInvalidLength) {
  718. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x01,
  719. /*additional_data_length=*/0x00, 0x00};
  720. base::RunLoop run_loop;
  721. auto callback = base::BindLambdaForTesting(
  722. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  723. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  724. run_loop.Quit();
  725. });
  726. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  727. run_loop.Run();
  728. }
  729. TEST_F(FastPairDataParserTest,
  730. ParseMessageStreamMessage_BleAddressUpdateInvalidLength) {
  731. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x02,
  732. /*additional_data_length=*/0x00, 0x00};
  733. base::RunLoop run_loop;
  734. auto callback = base::BindLambdaForTesting(
  735. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  736. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  737. run_loop.Quit();
  738. });
  739. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  740. run_loop.Run();
  741. }
  742. TEST_F(FastPairDataParserTest,
  743. ParseMessageStreamMessage_BatteryUpdateInvalidLength) {
  744. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x03,
  745. /*additional_data_length=*/0x00, 0x00};
  746. base::RunLoop run_loop;
  747. auto callback = base::BindLambdaForTesting(
  748. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  749. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  750. run_loop.Quit();
  751. });
  752. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  753. run_loop.Run();
  754. }
  755. TEST_F(FastPairDataParserTest,
  756. ParseMessageStreamMessage_RemainingBatteryInvalidLength) {
  757. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x04,
  758. /*additional_data_length=*/0x00, 0x00};
  759. base::RunLoop run_loop;
  760. auto callback = base::BindLambdaForTesting(
  761. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  762. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  763. run_loop.Quit();
  764. });
  765. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  766. run_loop.Run();
  767. }
  768. TEST_F(FastPairDataParserTest,
  769. ParseMessageStreamMessage_ActiveComponentsInvalidLength) {
  770. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x06,
  771. /*additional_data_length=*/0x00, 0x00};
  772. base::RunLoop run_loop;
  773. auto callback = base::BindLambdaForTesting(
  774. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  775. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  776. run_loop.Quit();
  777. });
  778. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  779. run_loop.Run();
  780. }
  781. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_ActiveComponents) {
  782. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x06,
  783. /*additional_data_length=*/0x00, 0x01,
  784. /*additional_data=*/0x03};
  785. base::RunLoop run_loop;
  786. auto callback = base::BindLambdaForTesting(
  787. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  788. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  789. EXPECT_TRUE(messages[0]->is_active_components_byte());
  790. EXPECT_EQ(messages[0]->get_active_components_byte(), 0x03);
  791. run_loop.Quit();
  792. });
  793. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  794. run_loop.Run();
  795. }
  796. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_AndroidPlatform) {
  797. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  798. /*mesage_code=*/0x08,
  799. /*additional_data_length=*/0x00,
  800. 0x02,
  801. /*additional_data=*/0x01,
  802. 0x1C};
  803. base::RunLoop run_loop;
  804. auto callback = base::BindLambdaForTesting(
  805. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  806. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  807. EXPECT_TRUE(messages[0]->is_sdk_version());
  808. EXPECT_EQ(messages[0]->get_sdk_version(), 28);
  809. run_loop.Quit();
  810. });
  811. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  812. run_loop.Run();
  813. }
  814. TEST_F(FastPairDataParserTest,
  815. ParseMessageStreamMessage_PlatformInvalidLength) {
  816. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03, /*mesage_code=*/0x08,
  817. /*additional_data_length=*/0x00, 0x00};
  818. base::RunLoop run_loop;
  819. auto callback = base::BindLambdaForTesting(
  820. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  821. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  822. run_loop.Quit();
  823. });
  824. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  825. run_loop.Run();
  826. }
  827. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_InvalidPlatform) {
  828. std::vector<uint8_t> bytes = {/*mesage_group=*/0x03,
  829. /*mesage_code=*/0x08,
  830. /*additional_data_length=*/0x00,
  831. 0x02,
  832. /*additional_data=*/0x02,
  833. 0x1C};
  834. base::RunLoop run_loop;
  835. auto callback = base::BindLambdaForTesting(
  836. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  837. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  838. run_loop.Quit();
  839. });
  840. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  841. run_loop.Run();
  842. }
  843. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_RingDeviceNoTimeout) {
  844. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04, /*mesage_code=*/0x01,
  845. /*additional_data_length=*/0x00, 0x01,
  846. /*additional_data=*/0x01};
  847. base::RunLoop run_loop;
  848. auto callback = base::BindLambdaForTesting(
  849. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  850. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  851. EXPECT_TRUE(messages[0]->is_ring_device_event());
  852. EXPECT_EQ(messages[0]->get_ring_device_event()->ring_device_byte, 0x01);
  853. EXPECT_EQ(messages[0]->get_ring_device_event()->timeout_in_seconds, -1);
  854. run_loop.Quit();
  855. });
  856. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  857. run_loop.Run();
  858. }
  859. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_RingDeviceTimeout) {
  860. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  861. /*mesage_code=*/0x01,
  862. /*additional_data_length=*/0x00,
  863. 0x02,
  864. /*additional_data=*/0x01,
  865. 0x3C};
  866. base::RunLoop run_loop;
  867. auto callback = base::BindLambdaForTesting(
  868. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  869. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  870. EXPECT_TRUE(messages[0]->is_ring_device_event());
  871. EXPECT_EQ(messages[0]->get_ring_device_event()->ring_device_byte, 0x01);
  872. EXPECT_EQ(messages[0]->get_ring_device_event()->timeout_in_seconds, 60);
  873. run_loop.Quit();
  874. });
  875. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  876. run_loop.Run();
  877. }
  878. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_RingInvalidLength) {
  879. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  880. /*mesage_code=*/0x01,
  881. /*additional_data_length=*/0x00,
  882. 0x03,
  883. /*additional_data=*/0x02,
  884. 0x1C,
  885. 0x02};
  886. base::RunLoop run_loop;
  887. auto callback = base::BindLambdaForTesting(
  888. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  889. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  890. run_loop.Quit();
  891. });
  892. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  893. run_loop.Run();
  894. }
  895. TEST_F(FastPairDataParserTest,
  896. ParseMessageStreamMessage_RingInvalidMessageCode) {
  897. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  898. /*mesage_code=*/0x02,
  899. /*additional_data_length=*/0x00,
  900. 0x02,
  901. /*additional_data=*/0x02,
  902. 0x1C};
  903. base::RunLoop run_loop;
  904. auto callback = base::BindLambdaForTesting(
  905. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  906. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  907. run_loop.Quit();
  908. });
  909. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  910. run_loop.Run();
  911. }
  912. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_Ack) {
  913. std::vector<uint8_t> bytes = {/*mesage_group=*/0xFF,
  914. /*mesage_code=*/0x01,
  915. /*additional_data_length=*/0x00,
  916. 0x02,
  917. /*additional_data=*/0x04,
  918. 0x01};
  919. base::RunLoop run_loop;
  920. auto callback = base::BindLambdaForTesting(
  921. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  922. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  923. EXPECT_TRUE(messages[0]->is_acknowledgement());
  924. EXPECT_EQ(messages[0]->get_acknowledgement()->action_message_code,
  925. 0x01);
  926. EXPECT_EQ(messages[0]->get_acknowledgement()->action_message_group,
  927. mojom::MessageGroup::kDeviceActionEvent);
  928. EXPECT_EQ(messages[0]->get_acknowledgement()->acknowledgement,
  929. mojom::Acknowledgement::kAck);
  930. run_loop.Quit();
  931. });
  932. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  933. run_loop.Run();
  934. }
  935. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_Nak) {
  936. std::vector<uint8_t> bytes = {/*mesage_group=*/0xFF,
  937. /*mesage_code=*/0x02,
  938. /*additional_data_length=*/0x00,
  939. 0x03,
  940. /*additional_data=*/0x00,
  941. 0x04,
  942. 0x01};
  943. base::RunLoop run_loop;
  944. auto callback = base::BindLambdaForTesting(
  945. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  946. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  947. EXPECT_TRUE(messages[0]->is_acknowledgement());
  948. EXPECT_EQ(messages[0]->get_acknowledgement()->action_message_code,
  949. 0x01);
  950. EXPECT_EQ(messages[0]->get_acknowledgement()->action_message_group,
  951. mojom::MessageGroup::kDeviceActionEvent);
  952. EXPECT_EQ(messages[0]->get_acknowledgement()->acknowledgement,
  953. mojom::Acknowledgement::kNotSupportedNak);
  954. run_loop.Quit();
  955. });
  956. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  957. run_loop.Run();
  958. }
  959. TEST_F(FastPairDataParserTest,
  960. ParseMessageStreamMessage_AckInvalidMessageCode) {
  961. std::vector<uint8_t> bytes = {/*mesage_group=*/0xFF,
  962. /*mesage_code=*/0x03,
  963. /*additional_data_length=*/0x00,
  964. 0x02,
  965. /*additional_data=*/0x04,
  966. 0x01};
  967. base::RunLoop run_loop;
  968. auto callback = base::BindLambdaForTesting(
  969. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  970. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  971. run_loop.Quit();
  972. });
  973. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  974. run_loop.Run();
  975. }
  976. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_AckInvalidLength) {
  977. std::vector<uint8_t> bytes = {/*mesage_group=*/0xFF,
  978. /*mesage_code=*/0x01,
  979. /*additional_data_length=*/0x00,
  980. 0x03,
  981. /*additional_data=*/0x04,
  982. 0x01,
  983. 0x01};
  984. base::RunLoop run_loop;
  985. auto callback = base::BindLambdaForTesting(
  986. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  987. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  988. run_loop.Quit();
  989. });
  990. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  991. run_loop.Run();
  992. }
  993. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_NakInvalidLength) {
  994. std::vector<uint8_t> bytes = {/*mesage_group=*/0xFF,
  995. /*mesage_code=*/0x02,
  996. /*additional_data_length=*/0x00,
  997. 0x02,
  998. /*additional_data=*/0x00,
  999. 0x04};
  1000. base::RunLoop run_loop;
  1001. auto callback = base::BindLambdaForTesting(
  1002. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  1003. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  1004. run_loop.Quit();
  1005. });
  1006. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  1007. run_loop.Run();
  1008. }
  1009. TEST_F(FastPairDataParserTest, ParseMessageStreamMessage_NotEnoughBytes) {
  1010. std::vector<uint8_t> bytes = {0x01, 0x02, 0x03};
  1011. base::RunLoop run_loop;
  1012. auto callback = base::BindLambdaForTesting(
  1013. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  1014. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  1015. run_loop.Quit();
  1016. });
  1017. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  1018. run_loop.Run();
  1019. }
  1020. TEST_F(FastPairDataParserTest,
  1021. ParseMessageStreamMessage_MultipleMessages_Valid) {
  1022. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  1023. /*mesage_code=*/0x01,
  1024. /*additional_data_length=*/0x00,
  1025. 0x01,
  1026. /*additional_data=*/0x01,
  1027. /*mesage_group=*/0x03,
  1028. /*mesage_code=*/0x08,
  1029. /*additional_data_length=*/0x00,
  1030. 0x02,
  1031. /*additional_data=*/0x01,
  1032. 0x1C};
  1033. base::RunLoop run_loop;
  1034. auto callback = base::BindLambdaForTesting(
  1035. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  1036. EXPECT_EQ(static_cast<int>(messages.size()), 2);
  1037. EXPECT_TRUE(messages[0]->is_ring_device_event());
  1038. EXPECT_EQ(messages[0]->get_ring_device_event()->ring_device_byte, 0x01);
  1039. EXPECT_EQ(messages[0]->get_ring_device_event()->timeout_in_seconds, -1);
  1040. EXPECT_TRUE(messages[1]->is_sdk_version());
  1041. EXPECT_EQ(messages[1]->get_sdk_version(), 28);
  1042. run_loop.Quit();
  1043. });
  1044. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  1045. run_loop.Run();
  1046. }
  1047. TEST_F(FastPairDataParserTest,
  1048. ParseMessageStreamMessage_MultipleMessages_ValidInvalid) {
  1049. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  1050. /*mesage_code=*/0x01,
  1051. /*additional_data_length=*/0x00,
  1052. 0x01,
  1053. /*additional_data=*/0x01,
  1054. /*mesage_group=*/0x03,
  1055. /*mesage_code=*/0x08,
  1056. /*additional_data_length=*/0x00,
  1057. 0x02,
  1058. /*additional_data=*/0x02,
  1059. 0x1C};
  1060. base::RunLoop run_loop;
  1061. auto callback = base::BindLambdaForTesting(
  1062. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  1063. EXPECT_EQ(static_cast<int>(messages.size()), 1);
  1064. EXPECT_TRUE(messages[0]->is_ring_device_event());
  1065. EXPECT_EQ(messages[0]->get_ring_device_event()->ring_device_byte, 0x01);
  1066. EXPECT_EQ(messages[0]->get_ring_device_event()->timeout_in_seconds, -1);
  1067. run_loop.Quit();
  1068. });
  1069. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  1070. run_loop.Run();
  1071. }
  1072. TEST_F(FastPairDataParserTest,
  1073. ParseMessageStreamMessage_MultipleMessages_Invalid) {
  1074. std::vector<uint8_t> bytes = {/*mesage_group=*/0x04,
  1075. /*mesage_code=*/0x01,
  1076. /*additional_data_length=*/0x00,
  1077. 0x00,
  1078. /*mesage_group=*/0x03,
  1079. /*mesage_code=*/0x08,
  1080. /*additional_data_length=*/0x00,
  1081. 0x02,
  1082. /*additional_data=*/0x02,
  1083. 0x1C};
  1084. base::RunLoop run_loop;
  1085. auto callback = base::BindLambdaForTesting(
  1086. [&run_loop](std::vector<mojom::MessageStreamMessagePtr> messages) {
  1087. EXPECT_EQ(static_cast<int>(messages.size()), 0);
  1088. run_loop.Quit();
  1089. });
  1090. data_parser_->ParseMessageStreamMessages(bytes, std::move(callback));
  1091. run_loop.Run();
  1092. }
  1093. } // namespace quick_pair
  1094. } // namespace ash