procfs_stat_cpu_parser_unittest.cc 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429
  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 "services/device/compute_pressure/procfs_stat_cpu_parser.h"
  5. #include <memory>
  6. #include <string>
  7. #include <vector>
  8. #include "base/files/file.h"
  9. #include "base/files/file_util.h"
  10. #include "base/files/scoped_temp_dir.h"
  11. #include "base/strings/string_piece_forward.h"
  12. #include "testing/gmock/include/gmock/gmock.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. namespace device {
  15. class ProcfsStatCpuParserTest : public testing::Test {
  16. public:
  17. ~ProcfsStatCpuParserTest() override = default;
  18. void SetUp() override {
  19. ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  20. fake_stat_path_ = temp_dir_.GetPath().AppendASCII("stat");
  21. // Create the /proc/stat file before creating the parser, in case the parser
  22. // implementation keeps an open handle to the file indefinitely.
  23. stat_file_ = base::File(fake_stat_path_, base::File::FLAG_CREATE_ALWAYS |
  24. base::File::FLAG_WRITE);
  25. parser_ = std::make_unique<ProcfsStatCpuParser>(fake_stat_path_);
  26. }
  27. [[nodiscard]] bool WriteFakeStat(base::StringPiece contents) {
  28. if (!stat_file_.SetLength(0))
  29. return false;
  30. if (contents.size() > 0) {
  31. if (!stat_file_.Write(0, contents.data(), contents.size()))
  32. return false;
  33. }
  34. return true;
  35. }
  36. protected:
  37. base::ScopedTempDir temp_dir_;
  38. base::FilePath fake_stat_path_;
  39. base::File stat_file_;
  40. std::unique_ptr<ProcfsStatCpuParser> parser_;
  41. };
  42. TEST_F(ProcfsStatCpuParserTest, ProductionData_NoCrash) {
  43. base::FilePath production_path(ProcfsStatCpuParser::kProcfsStatPath);
  44. ProcfsStatCpuParser parser(production_path);
  45. bool parse_success = parser.Update();
  46. if (!parse_success) {
  47. // Log /proc/stat for debugging.
  48. std::string stat_file = "(failed to read /proc/stat)";
  49. base::ReadFileToString(production_path, &stat_file);
  50. FAIL() << stat_file;
  51. }
  52. }
  53. TEST_F(ProcfsStatCpuParserTest, MissingFile) {
  54. stat_file_ = base::File();
  55. ASSERT_TRUE(base::DeleteFile(fake_stat_path_));
  56. ProcfsStatCpuParser parser(fake_stat_path_);
  57. EXPECT_FALSE(parser.Update());
  58. EXPECT_EQ(parser_->core_times().size(), 0u);
  59. }
  60. TEST_F(ProcfsStatCpuParserTest, EmptyFile) {
  61. ASSERT_TRUE(WriteFakeStat(""));
  62. EXPECT_EQ(0, stat_file_.GetLength()) << "Incorrect empty file";
  63. EXPECT_TRUE(parser_->Update());
  64. EXPECT_EQ(parser_->core_times().size(), 0u);
  65. }
  66. TEST_F(ProcfsStatCpuParserTest, SingleCore_SingleDigit) {
  67. // Zero is not used as a value, because it is the initial value of CoreTimes
  68. // members. Avoiding that value brings assurance that Update() modified the
  69. // CoreTimes member.
  70. ASSERT_TRUE(WriteFakeStat("cpu0 1 2 3 4 5 6 7 8 9 1"));
  71. EXPECT_TRUE(parser_->Update());
  72. ASSERT_EQ(parser_->core_times().size(), 1u);
  73. EXPECT_EQ(parser_->core_times()[0].user(), 1u);
  74. EXPECT_EQ(parser_->core_times()[0].nice(), 2u);
  75. EXPECT_EQ(parser_->core_times()[0].system(), 3u);
  76. EXPECT_EQ(parser_->core_times()[0].idle(), 4u);
  77. EXPECT_EQ(parser_->core_times()[0].iowait(), 5u);
  78. EXPECT_EQ(parser_->core_times()[0].irq(), 6u);
  79. EXPECT_EQ(parser_->core_times()[0].softirq(), 7u);
  80. EXPECT_EQ(parser_->core_times()[0].steal(), 8u);
  81. EXPECT_EQ(parser_->core_times()[0].guest(), 9u);
  82. EXPECT_EQ(parser_->core_times()[0].guest_nice(), 1u);
  83. }
  84. TEST_F(ProcfsStatCpuParserTest, SingleCore_MultipleDigits) {
  85. // Checks that the number parser can parse numbers of various sizes. The sizes
  86. // are not in ascending order, to make sure that the number size isn't in sync
  87. // with a loop counter.
  88. //
  89. // Number of digits in each number: 2 4 3 6 5 8 7 9 1 10
  90. ASSERT_TRUE(WriteFakeStat(
  91. "cpu0 12 3456 789 102345 67890 12345678 9012345 678901234 5 1234567890"));
  92. EXPECT_TRUE(parser_->Update());
  93. ASSERT_EQ(parser_->core_times().size(), 1u);
  94. EXPECT_EQ(parser_->core_times()[0].user(), 12u);
  95. EXPECT_EQ(parser_->core_times()[0].nice(), 3456u);
  96. EXPECT_EQ(parser_->core_times()[0].system(), 789u);
  97. EXPECT_EQ(parser_->core_times()[0].idle(), 102345u);
  98. EXPECT_EQ(parser_->core_times()[0].iowait(), 67890u);
  99. EXPECT_EQ(parser_->core_times()[0].irq(), 12345678u);
  100. EXPECT_EQ(parser_->core_times()[0].softirq(), 9012345u);
  101. EXPECT_EQ(parser_->core_times()[0].steal(), 678901234u);
  102. EXPECT_EQ(parser_->core_times()[0].guest(), 5u);
  103. EXPECT_EQ(parser_->core_times()[0].guest_nice(), 1234567890u);
  104. }
  105. TEST_F(ProcfsStatCpuParserTest, SingleCore_TooManyNumbers) {
  106. ASSERT_TRUE(WriteFakeStat("cpu0 10 11 12 13 14 15 16 17 18 19 20 21 22 23"));
  107. EXPECT_TRUE(parser_->Update());
  108. ASSERT_EQ(parser_->core_times().size(), 1u);
  109. EXPECT_EQ(parser_->core_times()[0].user(), 10u);
  110. EXPECT_EQ(parser_->core_times()[0].nice(), 11u);
  111. EXPECT_EQ(parser_->core_times()[0].system(), 12u);
  112. EXPECT_EQ(parser_->core_times()[0].idle(), 13u);
  113. EXPECT_EQ(parser_->core_times()[0].iowait(), 14u);
  114. EXPECT_EQ(parser_->core_times()[0].irq(), 15u);
  115. EXPECT_EQ(parser_->core_times()[0].softirq(), 16u);
  116. EXPECT_EQ(parser_->core_times()[0].steal(), 17u);
  117. EXPECT_EQ(parser_->core_times()[0].guest(), 18u);
  118. EXPECT_EQ(parser_->core_times()[0].guest_nice(), 19u);
  119. }
  120. TEST_F(ProcfsStatCpuParserTest, SingleCore_TooFewNumbers) {
  121. const std::vector<const char*> test_cases = {
  122. "cpu0 1 2 3 4 5 6 7 8 9",
  123. "cpu0 1 2 3 4 5 6 7 8",
  124. "cpu0 1 2 3 4 5 6 7",
  125. "cpu0 1 2 3 4 5 6",
  126. "cpu0 1 2 3 4 5",
  127. "cpu0 1 2 3 4",
  128. "cpu0 1 2 3",
  129. "cpu0 1 2",
  130. "cpu0 1",
  131. };
  132. for (const char* test_case : test_cases) {
  133. SCOPED_TRACE(test_case);
  134. ProcfsStatCpuParser parser(fake_stat_path_);
  135. ASSERT_TRUE(WriteFakeStat(test_case));
  136. EXPECT_TRUE(parser.Update());
  137. ASSERT_EQ(parser.core_times().size(), 1u);
  138. EXPECT_EQ(parser.core_times()[0].user(), 0u);
  139. EXPECT_EQ(parser.core_times()[0].nice(), 0u);
  140. EXPECT_EQ(parser.core_times()[0].system(), 0u);
  141. EXPECT_EQ(parser.core_times()[0].idle(), 0u);
  142. EXPECT_EQ(parser.core_times()[0].iowait(), 0u);
  143. EXPECT_EQ(parser.core_times()[0].irq(), 0u);
  144. EXPECT_EQ(parser.core_times()[0].softirq(), 0u);
  145. EXPECT_EQ(parser.core_times()[0].steal(), 0u);
  146. EXPECT_EQ(parser.core_times()[0].guest(), 0u);
  147. EXPECT_EQ(parser.core_times()[0].guest_nice(), 0u);
  148. }
  149. }
  150. TEST_F(ProcfsStatCpuParserTest, SingleCore_NoNumbers) {
  151. ASSERT_TRUE(WriteFakeStat("cpu0"));
  152. EXPECT_TRUE(parser_->Update());
  153. EXPECT_EQ(parser_->core_times().size(), 0u);
  154. }
  155. TEST_F(ProcfsStatCpuParserTest, IncorrectCoreSpecifier) {
  156. const std::vector<const char*> test_cases = {
  157. "dpu0 1 2 3 4 5 6 7 8 9 0",
  158. "cru0 1 2 3 4 5 6 7 8 9 0",
  159. "cpv0 1 2 3 4 5 6 7 8 9 0",
  160. "cpu 1 2 3 4 5 6 7 8 9 0",
  161. "cpua 1 2 3 4 5 6 7 8 9 0",
  162. "cpu- 1 2 3 4 5 6 7 8 9 0",
  163. "cpu-1 1 2 3 4 5 6 7 8 9 0",
  164. "cpu-100 1 2 3 4 5 6 7 8 9 0",
  165. "cpu1a 1 2 3 4 5 6 7 8 9 0",
  166. "cpu1- 1 2 3 4 5 6 7 8 9 0",
  167. "cpu\U0001f41b 1 2 3 4 5 6 7 8 9 0",
  168. "cpu1\U0001f41b 1 2 3 4 5 6 7 8 9 0",
  169. "cpu\U0001f41b1 1 2 3 4 5 6 7 8 9 0",
  170. };
  171. for (const char* test_case : test_cases) {
  172. SCOPED_TRACE(test_case);
  173. ProcfsStatCpuParser parser(fake_stat_path_);
  174. ASSERT_TRUE(WriteFakeStat(test_case));
  175. EXPECT_TRUE(parser.Update());
  176. EXPECT_EQ(parser.core_times().size(), 0u);
  177. }
  178. }
  179. TEST_F(ProcfsStatCpuParserTest, InvalidFirstNumber) {
  180. const std::vector<const char*> test_cases = {
  181. "cpu0 a 2 3 4 5 6 7 8 9 10",
  182. "cpu0 - 2 3 4 5 6 7 8 9 10",
  183. "cpu0 -1 2 3 4 5 6 7 8 9 10",
  184. "cpu0 -100 2 3 4 5 6 7 8 9 10",
  185. "cpu0 1a 2 3 4 5 6 7 8 9 10",
  186. "cpu0 1234a 2 3 4 5 6 7 8 9 10",
  187. "cpu0 123456789012345678901 2 3 4 5 6 7 8 9 10",
  188. "cpu0 -123456789012345678901 2 3 4 5 6 7 8 9 10",
  189. "cpu0 18446744073709551616 2 3 4 5 6 7 8 9 10",
  190. "cpu0 \U0001f41b 2 3 4 5 6 7 8 9 10",
  191. "cpu0 1\U0001f41b 2 3 4 5 6 7 8 9 10",
  192. "cpu0 \U0001f41b1 2 3 4 5 6 7 8 9 10",
  193. };
  194. for (const char* test_case : test_cases) {
  195. SCOPED_TRACE(test_case);
  196. ProcfsStatCpuParser parser(fake_stat_path_);
  197. ASSERT_TRUE(WriteFakeStat(test_case));
  198. EXPECT_TRUE(parser.Update());
  199. ASSERT_EQ(parser.core_times().size(), 1u);
  200. EXPECT_EQ(parser.core_times()[0].user(), 0u);
  201. EXPECT_EQ(parser.core_times()[0].nice(), 0u);
  202. EXPECT_EQ(parser.core_times()[0].system(), 0u);
  203. EXPECT_EQ(parser.core_times()[0].idle(), 0u);
  204. EXPECT_EQ(parser.core_times()[0].iowait(), 0u);
  205. EXPECT_EQ(parser.core_times()[0].irq(), 0u);
  206. EXPECT_EQ(parser.core_times()[0].softirq(), 0u);
  207. EXPECT_EQ(parser.core_times()[0].steal(), 0u);
  208. EXPECT_EQ(parser.core_times()[0].guest(), 0u);
  209. EXPECT_EQ(parser.core_times()[0].guest_nice(), 0u);
  210. }
  211. }
  212. TEST_F(ProcfsStatCpuParserTest, InvalidNumberSkipped) {
  213. struct TestCase {
  214. const char* line;
  215. int invalid_index;
  216. };
  217. const std::vector<TestCase> test_cases = {
  218. {"cpu0 1 2 3 4 5 6 7 8 9 10", 10},
  219. {"cpu0 a 2 3 4 5 6 7 8 9 10", 0},
  220. {"cpu0 1 a 3 4 5 6 7 8 9 10", 1},
  221. {"cpu0 1 2 a 4 5 6 7 8 9 10", 2},
  222. {"cpu0 1 2 3 a 5 6 7 8 9 10", 3},
  223. {"cpu0 1 2 3 4 a 6 7 8 9 10", 4},
  224. {"cpu0 1 2 3 4 5 a 7 8 9 10", 5},
  225. {"cpu0 1 2 3 4 5 6 a 8 9 10", 6},
  226. {"cpu0 1 2 3 4 5 6 7 a 9 10", 7},
  227. {"cpu0 1 2 3 4 5 6 7 8 a 10", 8},
  228. {"cpu0 1 2 3 4 5 6 7 8 9 a", 9},
  229. {"cpu0 1 \U0001f41b 3 4 5 6 7 8 9 10", 1},
  230. {"cpu0 1 2 3\U0001f41b 4 5 6 7 8 9 10", 2},
  231. {"cpu0 1 2 3 \U0001f41b4 5 6 7 8 9 10", 3},
  232. };
  233. for (const TestCase& test_case : test_cases) {
  234. SCOPED_TRACE(test_case.line);
  235. ProcfsStatCpuParser parser(fake_stat_path_);
  236. ASSERT_TRUE(WriteFakeStat(test_case.line));
  237. EXPECT_TRUE(parser.Update());
  238. ASSERT_EQ(parser.core_times().size(), 1u);
  239. EXPECT_EQ(parser.core_times()[0].user(),
  240. (test_case.invalid_index <= 0) ? 0u : 1u);
  241. EXPECT_EQ(parser.core_times()[0].nice(),
  242. (test_case.invalid_index <= 1) ? 0u : 2u);
  243. EXPECT_EQ(parser.core_times()[0].system(),
  244. (test_case.invalid_index <= 2) ? 0u : 3u);
  245. EXPECT_EQ(parser.core_times()[0].idle(),
  246. (test_case.invalid_index <= 3) ? 0u : 4u);
  247. EXPECT_EQ(parser.core_times()[0].iowait(),
  248. (test_case.invalid_index <= 4) ? 0u : 5u);
  249. EXPECT_EQ(parser.core_times()[0].irq(),
  250. (test_case.invalid_index <= 5) ? 0u : 6u);
  251. EXPECT_EQ(parser.core_times()[0].softirq(),
  252. (test_case.invalid_index <= 6) ? 0u : 7u);
  253. EXPECT_EQ(parser.core_times()[0].steal(),
  254. (test_case.invalid_index <= 7) ? 0u : 8u);
  255. EXPECT_EQ(parser.core_times()[0].guest(),
  256. (test_case.invalid_index <= 8) ? 0u : 9u);
  257. EXPECT_EQ(parser.core_times()[0].guest_nice(),
  258. (test_case.invalid_index <= 9) ? 0u : 10u);
  259. }
  260. }
  261. TEST_F(ProcfsStatCpuParserTest, SingleCore_IgnoresCounterDecrease) {
  262. struct TestCase {
  263. const char* line;
  264. int invalid_index;
  265. };
  266. const std::vector<TestCase> test_cases = {
  267. {"cpu0 106 116 126 136 146 156 166 176 186 196", 10},
  268. {"cpu0 104 116 126 136 146 156 166 176 186 196", 0},
  269. {"cpu0 106 114 126 136 146 156 166 176 186 196", 1},
  270. {"cpu0 106 116 124 136 146 156 166 176 186 196", 2},
  271. {"cpu0 106 116 126 134 146 156 166 176 186 196", 3},
  272. {"cpu0 106 116 126 136 144 156 166 176 186 196", 4},
  273. {"cpu0 106 116 126 136 146 154 166 176 186 196", 5},
  274. {"cpu0 106 116 126 136 146 156 164 176 186 196", 6},
  275. {"cpu0 106 116 126 136 146 156 166 174 186 196", 7},
  276. {"cpu0 106 116 126 136 146 156 166 176 184 196", 8},
  277. {"cpu0 106 116 126 136 146 156 166 176 186 194", 9},
  278. };
  279. for (const TestCase& test_case : test_cases) {
  280. SCOPED_TRACE(test_case.line);
  281. ProcfsStatCpuParser parser(fake_stat_path_);
  282. ASSERT_TRUE(WriteFakeStat("cpu0 105 115 125 135 145 155 165 175 185 195"));
  283. EXPECT_TRUE(parser.Update());
  284. ASSERT_EQ(parser.core_times().size(), 1u);
  285. ASSERT_TRUE(WriteFakeStat(test_case.line));
  286. EXPECT_TRUE(parser.Update());
  287. EXPECT_EQ(parser.core_times()[0].user(),
  288. (test_case.invalid_index == 0) ? 105u : 106u);
  289. EXPECT_EQ(parser.core_times()[0].nice(),
  290. (test_case.invalid_index == 1) ? 115u : 116u);
  291. EXPECT_EQ(parser.core_times()[0].system(),
  292. (test_case.invalid_index == 2) ? 125u : 126u);
  293. EXPECT_EQ(parser.core_times()[0].idle(),
  294. (test_case.invalid_index == 3) ? 135u : 136u);
  295. EXPECT_EQ(parser.core_times()[0].iowait(),
  296. (test_case.invalid_index == 4) ? 145u : 146u);
  297. EXPECT_EQ(parser.core_times()[0].irq(),
  298. (test_case.invalid_index == 5) ? 155u : 156u);
  299. EXPECT_EQ(parser.core_times()[0].softirq(),
  300. (test_case.invalid_index == 6) ? 165u : 166u);
  301. EXPECT_EQ(parser.core_times()[0].steal(),
  302. (test_case.invalid_index == 7) ? 175u : 176u);
  303. EXPECT_EQ(parser.core_times()[0].guest(),
  304. (test_case.invalid_index == 8) ? 185u : 186u);
  305. EXPECT_EQ(parser.core_times()[0].guest_nice(),
  306. (test_case.invalid_index == 9) ? 195u : 196u);
  307. }
  308. }
  309. TEST_F(ProcfsStatCpuParserTest, MissingCores) {
  310. ASSERT_TRUE(WriteFakeStat("cpu5 1 2 3 4 5 6 7 8 9 1"));
  311. EXPECT_TRUE(parser_->Update());
  312. ASSERT_EQ(parser_->core_times().size(), 6u);
  313. EXPECT_EQ(parser_->core_times()[5].user(), 1u);
  314. EXPECT_EQ(parser_->core_times()[5].nice(), 2u);
  315. EXPECT_EQ(parser_->core_times()[5].system(), 3u);
  316. EXPECT_EQ(parser_->core_times()[5].idle(), 4u);
  317. EXPECT_EQ(parser_->core_times()[5].iowait(), 5u);
  318. EXPECT_EQ(parser_->core_times()[5].irq(), 6u);
  319. EXPECT_EQ(parser_->core_times()[5].softirq(), 7u);
  320. EXPECT_EQ(parser_->core_times()[5].steal(), 8u);
  321. EXPECT_EQ(parser_->core_times()[5].guest(), 9u);
  322. EXPECT_EQ(parser_->core_times()[5].guest_nice(), 1u);
  323. for (int i = 0; i < 5; ++i) {
  324. EXPECT_EQ(parser_->core_times()[i].user(), 0u);
  325. EXPECT_EQ(parser_->core_times()[i].nice(), 0u);
  326. EXPECT_EQ(parser_->core_times()[i].system(), 0u);
  327. EXPECT_EQ(parser_->core_times()[i].idle(), 0u);
  328. EXPECT_EQ(parser_->core_times()[i].iowait(), 0u);
  329. EXPECT_EQ(parser_->core_times()[i].irq(), 0u);
  330. EXPECT_EQ(parser_->core_times()[i].softirq(), 0u);
  331. EXPECT_EQ(parser_->core_times()[i].steal(), 0u);
  332. EXPECT_EQ(parser_->core_times()[i].guest(), 0u);
  333. EXPECT_EQ(parser_->core_times()[i].guest_nice(), 0u);
  334. }
  335. }
  336. TEST_F(ProcfsStatCpuParserTest, MultipleCores) {
  337. ASSERT_TRUE(WriteFakeStat(R"(
  338. cpu 100 101 102 103 104 105 106 107 108 109
  339. cpu2 30 31 32 33 34 35 36 37 38 39
  340. cpu3 40 41 42 43 44 45 46 47 48 49
  341. cpu0 10 11 12 13 14 15 16 17 18 19
  342. cpu5 60 61 62 63 64 65 66 67 68 69
  343. cpu1 20 21 22 23 24 25 26 27 28 29
  344. cpu4 50 51 52 53 54 55 56 57 58 59
  345. intr 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
  346. ctxt 23456789012
  347. btime 1234567890
  348. processes 6789012
  349. procs_running 700
  350. procs_blocked 600
  351. softirq 900 901 902 903 904 905 906 907 908 909 910
  352. )"));
  353. EXPECT_TRUE(parser_->Update());
  354. ASSERT_EQ(parser_->core_times().size(), 6u);
  355. for (int i = 0; i < 6; ++i) {
  356. EXPECT_EQ(parser_->core_times()[i].user(),
  357. static_cast<uint64_t>(i * 10 + 10));
  358. EXPECT_EQ(parser_->core_times()[i].nice(),
  359. static_cast<uint64_t>(i * 10 + 11));
  360. EXPECT_EQ(parser_->core_times()[i].system(),
  361. static_cast<uint64_t>(i * 10 + 12));
  362. EXPECT_EQ(parser_->core_times()[i].idle(),
  363. static_cast<uint64_t>(i * 10 + 13));
  364. EXPECT_EQ(parser_->core_times()[i].iowait(),
  365. static_cast<uint64_t>(i * 10 + 14));
  366. EXPECT_EQ(parser_->core_times()[i].irq(),
  367. static_cast<uint64_t>(i * 10 + 15));
  368. EXPECT_EQ(parser_->core_times()[i].softirq(),
  369. static_cast<uint64_t>(i * 10 + 16));
  370. EXPECT_EQ(parser_->core_times()[i].steal(),
  371. static_cast<uint64_t>(i * 10 + 17));
  372. EXPECT_EQ(parser_->core_times()[i].guest(),
  373. static_cast<uint64_t>(i * 10 + 18));
  374. EXPECT_EQ(parser_->core_times()[i].guest_nice(),
  375. static_cast<uint64_t>(i * 10 + 19));
  376. }
  377. }
  378. } // namespace device