1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <memory> 20 21 #include "export_test.h" 22 #include "file.h" 23 #include "sph_data.pb.h" 24 #include "sph_data.pbreader.h" 25 #include "cpu_data_parser/pbreader_cpu_data_parser.h" 26 #include "parser/ptreader_parser/ptreader_parser.h" 27 #include "parser/common_types.h" 28 #include "sqllite_prepar_cache_data.h" 29 30 using namespace testing::ext; 31 using namespace SysTuning; 32 using namespace SysTuning::TraceStreamer; 33 namespace SysTuning { 34 namespace TraceStreamer { 35 namespace SqlitePreparCacheUnitTest { 36 const int32_t PROCESS_ID = 100; 37 const int32_t CPU = 101; 38 const int32_t PID = 102; 39 const int32_t TID = 103; 40 const int32_t UID = 104; 41 const int32_t IPID = 105; 42 const int32_t ID = 106; 43 const int32_t VALUE = 107; 44 const int32_t MAXX = 108; 45 const int32_t MINN = 109; 46 const int32_t DEPTH = 111; 47 const int32_t ITID = 112; 48 const int32_t FILTER_ID = 113; 49 const int32_t ARG_SET_ID = 114; 50 const int32_t DURATION = 115; 51 const int32_t DELTA = 116; 52 const int32_t INT_NAME = 117; 53 const int32_t JANK_TAG = 118; 54 const int32_t RS_VSYNC = 119; 55 const int32_t RS_IPID = 120; 56 const int32_t RS_PID = 121; 57 const int32_t RS_NAME = 122; 58 const int32_t ANIMATION_ID = 123; 59 const int32_t STATUS = 124; 60 const int32_t START_NAME = 125; 61 const int32_t INT_TYPE = 126; 62 const int32_t TRACK_ID = 127; 63 const int32_t PARENT_ID = 128; 64 const int32_t COOKIE = 129; 65 66 const int64_t DUR = 10000; 67 const int64_t START_TIME = 10001; 68 const int64_t START_NS = 10002; 69 const int64_t START_TS = 10003; 70 const int64_t END_TS = 10004; 71 const int64_t TS = 10005; 72 const int64_t MAX_VALUE = 10006; 73 const int64_t APP_DUR = 10007; 74 const int64_t RS_TS = 10008; 75 const int64_t RS_DUR = 10009; 76 const int64_t CURRENT_TS = 10010; 77 const int64_t END_NS = 10011; 78 const int64_t ARGSETTID = 10012; 79 const int64_t EVENT_COUNT = 10013; 80 const int64_t SAMPLE_COUNT = 10014; 81 const int64_t EVENT_TYPE_ID = 10015; 82 const int64_t CALLCHAIN_ID = 10016; 83 const int64_t THREAD_ID = 10017; 84 const int64_t CPU_ID = 10018; 85 const int64_t FILE_ID = 10019; 86 const int64_t SYMBOL_ID = 10020; 87 const int64_t IS_MAIN_THREAD = 10021; 88 const int64_t SIZE = 10022; 89 const int64_t FUNCTION_ID = 10023; 90 const int64_t END_TIME = 10024; 91 const int64_t URL_ID = 10025; 92 const int64_t LINE = 10026; 93 const int64_t COLUMN = 10027; 94 const int64_t HIT_COUNT = 10028; 95 const int64_t CHILDREN_STRING = 10029; 96 const int64_t INT_NAME_ID = 10030; 97 const int64_t HEAP_SIZE = 10031; 98 const int64_t EVENT_TYPE = 10032; 99 const int64_t APPLY_COUNT = 10033; 100 const int64_t APPLY_SIZE = 10034; 101 const int64_t RELEASE_COUNT = 10034; 102 const int64_t RELEASE_SIZE = 10034; 103 104 const std::string SEQ = "seq"; 105 const std::string EVENT_NAME = "enent_name"; 106 const std::string APP_KEY = "app_key"; 107 const std::string EVENT_VALUE = "event_value"; 108 const std::string FRAME_TYPE = "prame_type"; 109 const std::string TYPE = "type"; 110 const std::string CMDLINE = "cmdline"; 111 const std::string NAME = "name"; 112 const std::string X = "x"; 113 const std::string Y = "y"; 114 const std::string WIDTH = "width"; 115 const std::string HEIGHT = "height"; 116 const std::string ALPHA = "alpha"; 117 const std::string APP_NAME = "app_name"; 118 const std::string CURRENT_FRAME_WIDTH = "current_frame_width"; 119 const std::string CURRENT_FRAME_HEIGHT = "current_frame_height"; 120 const std::string NAME_ID = "name_id"; 121 const std::string STATE = "STATE"; 122 const std::string SVALUE = "VALUE"; 123 124 class SqllitePreparCacheDataTest : public testing::Test { SetUp()125 void SetUp() 126 { 127 stream_.InitFilter(); 128 } 129 TearDown()130 void TearDown() {} 131 132 public: 133 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 134 }; 135 136 /** 137 * @tc.name: ParseBatchSphDataWithSphCpuData 138 * @tc.desc: Parse a BatchSphData with SphCpuData 139 * @tc.type: FUNC 140 */ 141 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphCpuData, TestSize.Level1) 142 { 143 TS_LOGI("test42-1"); 144 SqllitePreparCacheData sqllitePreparCacheData; 145 BatchSphData batchSphCpuData; 146 auto sphCpuData = batchSphCpuData.add_values()->mutable_cpu_data(); 147 sphCpuData->set_process_id(PROCESS_ID); 148 sphCpuData->set_cpu(CPU); 149 sphCpuData->set_tid(TID); 150 sphCpuData->set_id(ID); 151 sphCpuData->set_dur(DUR); 152 sphCpuData->set_start_time(START_TIME); 153 154 std::string sphStrMsg = ""; 155 batchSphCpuData.SerializeToString(&sphStrMsg); 156 BatchSphData batchSphCpuDataResult; 157 batchSphCpuDataResult.ParseFromString(sphStrMsg); 158 EXPECT_EQ(batchSphCpuDataResult.values_size(), 1); 159 EXPECT_TRUE(batchSphCpuDataResult.values(0).has_cpu_data()); 160 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().process_id(), PROCESS_ID); 161 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().cpu(), CPU); 162 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().tid(), TID); 163 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().id(), ID); 164 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().dur(), DUR); 165 EXPECT_EQ(batchSphCpuDataResult.values(0).cpu_data().start_time(), START_TIME); 166 } 167 168 /** 169 * @tc.name: ParseBatchSphDataWithSphCpuStateData 170 * @tc.desc: Parse a BatchSphData with SphCpuStateData 171 * @tc.type: FUNC 172 */ 173 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphCpuStateData, TestSize.Level1) 174 { 175 TS_LOGI("test42-2"); 176 177 BatchSphData batchSphCpuStateData; 178 auto sphCpuStateData = batchSphCpuStateData.add_values()->mutable_cpu_state_data(); 179 sphCpuStateData->set_value(VALUE); 180 sphCpuStateData->set_dur(DUR); 181 sphCpuStateData->set_start_ts(START_TS); 182 183 std::string sphStrMsg = ""; 184 batchSphCpuStateData.SerializeToString(&sphStrMsg); 185 BatchSphData batchSphCpuStateDataResult; 186 batchSphCpuStateDataResult.ParseFromString(sphStrMsg); 187 EXPECT_EQ(batchSphCpuStateDataResult.values_size(), 1); 188 EXPECT_TRUE(batchSphCpuStateDataResult.values(0).has_cpu_state_data()); 189 EXPECT_EQ(batchSphCpuStateDataResult.values(0).cpu_state_data().value(), VALUE); 190 EXPECT_EQ(batchSphCpuStateDataResult.values(0).cpu_state_data().dur(), DUR); 191 EXPECT_EQ(batchSphCpuStateDataResult.values(0).cpu_state_data().start_ts(), START_TS); 192 } 193 194 /** 195 * @tc.name: ParseBatchSphDataWithSphCpuFreqData 196 * @tc.desc: Parse a BatchSphData with SphCpuFreqData 197 * @tc.type: FUNC 198 */ 199 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphCpuFreqData, TestSize.Level1) 200 { 201 TS_LOGI("test42-3"); 202 203 BatchSphData batchSphCpuFreqData; 204 auto sphCpuFreqData = batchSphCpuFreqData.add_values()->mutable_cpu_freq_data(); 205 sphCpuFreqData->set_cpu(CPU); 206 sphCpuFreqData->set_value(VALUE); 207 sphCpuFreqData->set_dur(DUR); 208 sphCpuFreqData->set_start_ns(START_NS); 209 210 std::string sphStrMsg = ""; 211 batchSphCpuFreqData.SerializeToString(&sphStrMsg); 212 BatchSphData batchSphCpuFreqDataResult; 213 batchSphCpuFreqDataResult.ParseFromString(sphStrMsg); 214 EXPECT_EQ(batchSphCpuFreqDataResult.values_size(), 1); 215 EXPECT_TRUE(batchSphCpuFreqDataResult.values(0).has_cpu_freq_data()); 216 EXPECT_EQ(batchSphCpuFreqDataResult.values(0).cpu_freq_data().cpu(), CPU); 217 EXPECT_EQ(batchSphCpuFreqDataResult.values(0).cpu_freq_data().value(), VALUE); 218 EXPECT_EQ(batchSphCpuFreqDataResult.values(0).cpu_freq_data().dur(), DUR); 219 EXPECT_EQ(batchSphCpuFreqDataResult.values(0).cpu_freq_data().start_ns(), START_NS); 220 } 221 222 /** 223 * @tc.name: ParseBatchSphDataWithSphCpuFreqLimitData 224 * @tc.desc: Parse a BatchSphData with SphCpuFreqLimitData 225 * @tc.type: FUNC 226 */ 227 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphCpuFreqLimitData, TestSize.Level1) 228 { 229 TS_LOGI("test42-4"); 230 231 BatchSphData batchSphCpuFreqLimitData; 232 auto sphCpuFreqLimitData = batchSphCpuFreqLimitData.add_values()->mutable_cpu_freq_limit_data(); 233 sphCpuFreqLimitData->set_max(MAXX); 234 sphCpuFreqLimitData->set_min(MINN); 235 sphCpuFreqLimitData->set_value(VALUE); 236 sphCpuFreqLimitData->set_dur(DUR); 237 sphCpuFreqLimitData->set_start_ns(START_NS); 238 239 std::string sphStrMsg = ""; 240 batchSphCpuFreqLimitData.SerializeToString(&sphStrMsg); 241 BatchSphData batchSphCpuFreqLimitDataResult; 242 batchSphCpuFreqLimitDataResult.ParseFromString(sphStrMsg); 243 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values_size(), 1); 244 EXPECT_TRUE(batchSphCpuFreqLimitDataResult.values(0).has_cpu_freq_limit_data()); 245 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values(0).cpu_freq_limit_data().max(), MAXX); 246 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values(0).cpu_freq_limit_data().min(), MINN); 247 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values(0).cpu_freq_limit_data().value(), VALUE); 248 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values(0).cpu_freq_limit_data().dur(), DUR); 249 EXPECT_EQ(batchSphCpuFreqLimitDataResult.values(0).cpu_freq_limit_data().start_ns(), START_NS); 250 } 251 252 /** 253 * @tc.name: ParseBatchSphDataWithSphClockData 254 * @tc.desc: Parse a BatchSphData with SphClockData 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphClockData, TestSize.Level1) 258 { 259 TS_LOGI("test42-5"); 260 261 BatchSphData batchSphClockData; 262 auto sphClockData = batchSphClockData.add_values()->mutable_clock_data(); 263 sphClockData->set_filter_id(FILTER_ID); 264 sphClockData->set_value(VALUE); 265 sphClockData->set_start_ns(START_NS); 266 267 std::string sphStrMsg = ""; 268 batchSphClockData.SerializeToString(&sphStrMsg); 269 BatchSphData batchSphClockDataResult; 270 batchSphClockDataResult.ParseFromString(sphStrMsg); 271 EXPECT_EQ(batchSphClockDataResult.values_size(), 1); 272 EXPECT_TRUE(batchSphClockDataResult.values(0).has_clock_data()); 273 EXPECT_EQ(batchSphClockDataResult.values(0).clock_data().filter_id(), FILTER_ID); 274 EXPECT_EQ(batchSphClockDataResult.values(0).clock_data().value(), VALUE); 275 EXPECT_EQ(batchSphClockDataResult.values(0).clock_data().start_ns(), START_NS); 276 } 277 278 /** 279 * @tc.name: ParseBatchSphDataWithSphIrqData 280 * @tc.desc: Parse a BatchSphData with SphIrqData 281 * @tc.type: FUNC 282 */ 283 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphIrqData, TestSize.Level1) 284 { 285 TS_LOGI("test42-6"); 286 287 BatchSphData batchSphIrqData; 288 auto sphIrqData = batchSphIrqData.add_values()->mutable_irq_data(); 289 sphIrqData->set_start_ns(START_NS); 290 sphIrqData->set_dur(DUR); 291 sphIrqData->set_depth(DEPTH); 292 sphIrqData->set_arg_set_id(ARG_SET_ID); 293 294 std::string sphStrMsg = ""; 295 batchSphIrqData.SerializeToString(&sphStrMsg); 296 BatchSphData batchSphIrqDataResult; 297 batchSphIrqDataResult.ParseFromString(sphStrMsg); 298 EXPECT_EQ(batchSphIrqDataResult.values_size(), 1); 299 EXPECT_TRUE(batchSphIrqDataResult.values(0).has_irq_data()); 300 EXPECT_EQ(batchSphIrqDataResult.values(0).irq_data().start_ns(), START_NS); 301 EXPECT_EQ(batchSphIrqDataResult.values(0).irq_data().dur(), DUR); 302 EXPECT_EQ(batchSphIrqDataResult.values(0).irq_data().depth(), DEPTH); 303 EXPECT_EQ(batchSphIrqDataResult.values(0).irq_data().arg_set_id(), ARG_SET_ID); 304 } 305 306 /** 307 * @tc.name: ParseBatchSphDataWithSphProcessData 308 * @tc.desc: Parse a BatchSphData with SphProcessData 309 * @tc.type: FUNC 310 */ 311 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessData, TestSize.Level1) 312 { 313 TS_LOGI("test42-7"); 314 315 BatchSphData batchSphProcessData; 316 auto sphProcessData = batchSphProcessData.add_values()->mutable_process_data(); 317 sphProcessData->set_cpu(CPU); 318 sphProcessData->set_dur(DUR); 319 sphProcessData->set_start_time(START_TIME); 320 321 std::string sphStrMsg = ""; 322 batchSphProcessData.SerializeToString(&sphStrMsg); 323 BatchSphData batchSphProcessDataResult; 324 batchSphProcessDataResult.ParseFromString(sphStrMsg); 325 EXPECT_EQ(batchSphProcessDataResult.values_size(), 1); 326 EXPECT_TRUE(batchSphProcessDataResult.values(0).has_process_data()); 327 EXPECT_EQ(batchSphProcessDataResult.values(0).process_data().cpu(), CPU); 328 EXPECT_EQ(batchSphProcessDataResult.values(0).process_data().dur(), DUR); 329 EXPECT_EQ(batchSphProcessDataResult.values(0).process_data().start_time(), START_TIME); 330 } 331 332 /** 333 * @tc.name: ParseBatchSphDataWithSphProcessMemData 334 * @tc.desc: Parse a BatchSphData with SphProcessMemData 335 * @tc.type: FUNC 336 */ 337 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessMemData, TestSize.Level1) 338 { 339 TS_LOGI("test42-8"); 340 341 BatchSphData batchSphProcessMemData; 342 auto sphProcessMemData = batchSphProcessMemData.add_values()->mutable_process_mem_data(); 343 sphProcessMemData->set_track_id(TRACK_ID); 344 sphProcessMemData->set_value(VALUE); 345 sphProcessMemData->set_start_time(START_TIME); 346 sphProcessMemData->set_ts(TS); 347 348 std::string sphStrMsg = ""; 349 batchSphProcessMemData.SerializeToString(&sphStrMsg); 350 BatchSphData batchSphProcessMemDataResult; 351 batchSphProcessMemDataResult.ParseFromString(sphStrMsg); 352 EXPECT_EQ(batchSphProcessMemDataResult.values_size(), 1); 353 EXPECT_TRUE(batchSphProcessMemDataResult.values(0).has_process_mem_data()); 354 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_mem_data().track_id(), TRACK_ID); 355 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_mem_data().value(), VALUE); 356 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_mem_data().start_time(), START_TIME); 357 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_mem_data().ts(), TS); 358 } 359 360 /** 361 * @tc.name: ParseBatchSphDataWithSphProcessStartupData 362 * @tc.desc: Parse a BatchSphData with SphProcessStartupData 363 * @tc.type: FUNC 364 */ 365 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessStartupData, TestSize.Level1) 366 { 367 TS_LOGI("test42-9"); 368 369 BatchSphData batchSphProcessStartupData; 370 auto sphProcessStartupData = batchSphProcessStartupData.add_values()->mutable_process_startup_data(); 371 sphProcessStartupData->set_pid(PID); 372 sphProcessStartupData->set_tid(TID); 373 sphProcessStartupData->set_itid(ITID); 374 sphProcessStartupData->set_start_time(START_TIME); 375 sphProcessStartupData->set_dur(DUR); 376 sphProcessStartupData->set_start_name(START_NAME); 377 378 std::string sphStrMsg = ""; 379 batchSphProcessStartupData.SerializeToString(&sphStrMsg); 380 BatchSphData batchSphProcessStartupDataResult; 381 batchSphProcessStartupDataResult.ParseFromString(sphStrMsg); 382 EXPECT_EQ(batchSphProcessStartupDataResult.values_size(), 1); 383 EXPECT_TRUE(batchSphProcessStartupDataResult.values(0).has_process_startup_data()); 384 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().pid(), PID); 385 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().tid(), TID); 386 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().itid(), ITID); 387 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().start_time(), START_TIME); 388 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().dur(), DUR); 389 EXPECT_EQ(batchSphProcessStartupDataResult.values(0).process_startup_data().start_name(), START_NAME); 390 } 391 392 /** 393 * @tc.name: ParseBatchSphDataWithSphProcessSoInitData 394 * @tc.desc: Parse a BatchSphData with SphProcessSoInitData 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessSoInitData, TestSize.Level1) 398 { 399 TS_LOGI("test42-10"); 400 401 BatchSphData batchSphProcessSoInitData; 402 auto sphProcessSoInitData = batchSphProcessSoInitData.add_values()->mutable_process_soinit_data(); 403 sphProcessSoInitData->set_depth(DEPTH); 404 sphProcessSoInitData->set_pid(PID); 405 sphProcessSoInitData->set_tid(TID); 406 sphProcessSoInitData->set_itid(ITID); 407 sphProcessSoInitData->set_start_time(START_TIME); 408 sphProcessSoInitData->set_dur(DUR); 409 sphProcessSoInitData->set_id(ID); 410 411 std::string sphStrMsg = ""; 412 batchSphProcessSoInitData.SerializeToString(&sphStrMsg); 413 BatchSphData batchSphProcessMemDataResult; 414 batchSphProcessMemDataResult.ParseFromString(sphStrMsg); 415 EXPECT_EQ(batchSphProcessMemDataResult.values_size(), 1); 416 EXPECT_TRUE(batchSphProcessMemDataResult.values(0).has_process_soinit_data()); 417 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().depth(), DEPTH); 418 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().pid(), PID); 419 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().tid(), TID); 420 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().itid(), ITID); 421 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().start_time(), START_TIME); 422 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().dur(), DUR); 423 EXPECT_EQ(batchSphProcessMemDataResult.values(0).process_soinit_data().id(), ID); 424 } 425 426 /** 427 * @tc.name: ParseBatchSphDataWithSphHiSysEventData 428 * @tc.desc: Parse a BatchSphData with SphHiSysEventData 429 * @tc.type: FUNC 430 */ 431 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphHiSysEventData, TestSize.Level1) 432 { 433 TS_LOGI("test42-11"); 434 435 BatchSphData batchSphHiSysEventData; 436 auto sphHiSysEventData = batchSphHiSysEventData.add_values()->mutable_hi_sys_event_data(); 437 sphHiSysEventData->set_id(ID); 438 sphHiSysEventData->set_ts(TS); 439 sphHiSysEventData->set_pid(PID); 440 sphHiSysEventData->set_tid(TID); 441 sphHiSysEventData->set_uid(UID); 442 sphHiSysEventData->set_seq(SEQ); 443 sphHiSysEventData->set_depth(DEPTH); 444 sphHiSysEventData->set_dur(DUR); 445 446 std::string sphStrMsg = ""; 447 batchSphHiSysEventData.SerializeToString(&sphStrMsg); 448 BatchSphData batchSphHiSysEventDataResult; 449 batchSphHiSysEventDataResult.ParseFromString(sphStrMsg); 450 EXPECT_EQ(batchSphHiSysEventDataResult.values_size(), 1); 451 EXPECT_TRUE(batchSphHiSysEventDataResult.values(0).has_hi_sys_event_data()); 452 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().id(), ID); 453 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().ts(), TS); 454 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().pid(), PID); 455 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().tid(), TID); 456 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().uid(), UID); 457 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().seq(), SEQ); 458 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().depth(), DEPTH); 459 EXPECT_EQ(batchSphHiSysEventDataResult.values(0).hi_sys_event_data().dur(), DUR); 460 } 461 462 /** 463 * @tc.name: ParseBatchSphDataWithSphLogData 464 * @tc.desc: Parse a BatchSphData with SphLogData 465 * @tc.type: FUNC 466 */ 467 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphLogData, TestSize.Level1) 468 { 469 TS_LOGI("test42-12"); 470 471 BatchSphData batchSphLogData; 472 auto sphLogData = batchSphLogData.add_values()->mutable_log_data(); 473 sphLogData->set_id(ID); 474 sphLogData->set_pid(PID); 475 sphLogData->set_tid(TID); 476 sphLogData->set_start_ts(START_TS); 477 sphLogData->set_depth(DEPTH); 478 sphLogData->set_dur(DUR); 479 480 std::string sphStrMsg = ""; 481 batchSphLogData.SerializeToString(&sphStrMsg); 482 BatchSphData batchSphLogDataResult; 483 batchSphLogDataResult.ParseFromString(sphStrMsg); 484 EXPECT_EQ(batchSphLogDataResult.values_size(), 1); 485 EXPECT_TRUE(batchSphLogDataResult.values(0).has_log_data()); 486 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().id(), ID); 487 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().pid(), PID); 488 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().tid(), TID); 489 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().start_ts(), START_TS); 490 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().depth(), DEPTH); 491 EXPECT_EQ(batchSphLogDataResult.values(0).log_data().dur(), DUR); 492 } 493 494 /** 495 * @tc.name: ParseBatchSphDataWithSphVirtualMemData 496 * @tc.desc: Parse a BatchSphData with SphVirtualMemData 497 * @tc.type: FUNC 498 */ 499 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphVirtualMemData, TestSize.Level1) 500 { 501 TS_LOGI("test42-13"); 502 503 BatchSphData batchSphVirtualMemData; 504 auto sphVirtualMemData = batchSphVirtualMemData.add_values()->mutable_virtual_mem_data(); 505 sphVirtualMemData->set_start_time(START_TIME); 506 sphVirtualMemData->set_filter_id(FILTER_ID); 507 sphVirtualMemData->set_value(VALUE); 508 sphVirtualMemData->set_duration(DURATION); 509 sphVirtualMemData->set_max_value(MAX_VALUE); 510 sphVirtualMemData->set_delta(DELTA); 511 512 std::string sphStrMsg = ""; 513 batchSphVirtualMemData.SerializeToString(&sphStrMsg); 514 BatchSphData batchSphVirtualMemDataResult; 515 batchSphVirtualMemDataResult.ParseFromString(sphStrMsg); 516 EXPECT_EQ(batchSphVirtualMemDataResult.values_size(), 1); 517 EXPECT_TRUE(batchSphVirtualMemDataResult.values(0).has_virtual_mem_data()); 518 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().start_time(), START_TIME); 519 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().filter_id(), FILTER_ID); 520 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().value(), VALUE); 521 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().duration(), DURATION); 522 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().max_value(), MAX_VALUE); 523 EXPECT_EQ(batchSphVirtualMemDataResult.values(0).virtual_mem_data().delta(), DELTA); 524 } 525 526 /** 527 * @tc.name: ParseBatchSphDataWithSphEnergyData 528 * @tc.desc: Parse a BatchSphData with SphEnergyData 529 * @tc.type: FUNC 530 */ 531 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphEnergyData, TestSize.Level1) 532 { 533 TS_LOGI("test42-14"); 534 535 BatchSphData batchSphEnergyData; 536 auto sphEnergyData = batchSphEnergyData.add_values()->mutable_energy_data(); 537 sphEnergyData->set_id(ID); 538 sphEnergyData->set_start_ns(START_NS); 539 sphEnergyData->set_event_name(EVENT_NAME); 540 sphEnergyData->set_app_key(APP_KEY); 541 sphEnergyData->set_event_value(EVENT_VALUE); 542 543 std::string sphStrMsg = ""; 544 batchSphEnergyData.SerializeToString(&sphStrMsg); 545 BatchSphData batchSphEnergyDataResult; 546 batchSphEnergyDataResult.ParseFromString(sphStrMsg); 547 EXPECT_EQ(batchSphEnergyDataResult.values_size(), 1); 548 EXPECT_TRUE(batchSphEnergyDataResult.values(0).has_energy_data()); 549 EXPECT_EQ(batchSphEnergyDataResult.values(0).energy_data().id(), ID); 550 EXPECT_EQ(batchSphEnergyDataResult.values(0).energy_data().start_ns(), START_NS); 551 EXPECT_EQ(batchSphEnergyDataResult.values(0).energy_data().event_name(), EVENT_NAME); 552 EXPECT_EQ(batchSphEnergyDataResult.values(0).energy_data().app_key(), APP_KEY); 553 EXPECT_EQ(batchSphEnergyDataResult.values(0).energy_data().event_value(), EVENT_VALUE); 554 } 555 556 /** 557 * @tc.name: ParseBatchSphDataWithSphFrameData 558 * @tc.desc: Parse a BatchSphData with SphFrameData 559 * @tc.type: FUNC 560 */ 561 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphFrameData, TestSize.Level1) 562 { 563 TS_LOGI("test42-15"); 564 565 BatchSphData batchSphFrameData; 566 auto sphFrameData = batchSphFrameData.add_values()->mutable_frame_data(); 567 sphFrameData->set_id(ID); 568 sphFrameData->set_frame_type(FRAME_TYPE); 569 sphFrameData->set_ipid(IPID); 570 sphFrameData->set_name(INT_NAME); 571 sphFrameData->set_app_dur(APP_DUR); 572 sphFrameData->set_dur(DUR); 573 sphFrameData->set_ts(TS); 574 sphFrameData->set_type(TYPE); 575 sphFrameData->set_jank_tag(JANK_TAG); 576 sphFrameData->set_pid(PID); 577 sphFrameData->set_cmdline(CMDLINE); 578 sphFrameData->set_rs_ts(RS_TS); 579 sphFrameData->set_rs_vsync(RS_VSYNC); 580 sphFrameData->set_rs_dur(RS_DUR); 581 sphFrameData->set_rs_ipid(RS_IPID); 582 sphFrameData->set_rs_pid(RS_PID); 583 sphFrameData->set_rs_name(RS_NAME); 584 585 std::string sphStrMsg = ""; 586 batchSphFrameData.SerializeToString(&sphStrMsg); 587 BatchSphData batchSphFrameDataResult; 588 batchSphFrameDataResult.ParseFromString(sphStrMsg); 589 EXPECT_EQ(batchSphFrameDataResult.values_size(), 1); 590 EXPECT_TRUE(batchSphFrameDataResult.values(0).has_frame_data()); 591 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().id(), ID); 592 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().frame_type(), FRAME_TYPE); 593 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().ipid(), IPID); 594 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().name(), INT_NAME); 595 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().app_dur(), APP_DUR); 596 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().dur(), DUR); 597 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().ts(), TS); 598 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().type(), TYPE); 599 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().jank_tag(), JANK_TAG); 600 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().pid(), PID); 601 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().cmdline(), CMDLINE); 602 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_ts(), RS_TS); 603 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_vsync(), RS_VSYNC); 604 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_dur(), RS_DUR); 605 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_ipid(), RS_IPID); 606 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_pid(), RS_PID); 607 EXPECT_EQ(batchSphFrameDataResult.values(0).frame_data().rs_name(), RS_NAME); 608 } 609 610 /** 611 * @tc.name: ParseBatchSphDataWithSphFrameAnimationData 612 * @tc.desc: Parse a BatchSphData with SphFrameAnimationData 613 * @tc.type: FUNC 614 */ 615 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphFrameAnimationData, TestSize.Level1) 616 { 617 TS_LOGI("test42-16"); 618 619 BatchSphData batchSphFrameAnimationData; 620 auto sphFrameAnimationData = batchSphFrameAnimationData.add_values()->mutable_frame_animation_data(); 621 sphFrameAnimationData->set_animation_id(ANIMATION_ID); 622 sphFrameAnimationData->set_status(STATUS); 623 sphFrameAnimationData->set_start_ts(START_TS); 624 sphFrameAnimationData->set_end_ts(END_TS); 625 sphFrameAnimationData->set_name(NAME); 626 627 std::string sphStrMsg = ""; 628 batchSphFrameAnimationData.SerializeToString(&sphStrMsg); 629 BatchSphData batchSphFrameAnimationDataResult; 630 batchSphFrameAnimationDataResult.ParseFromString(sphStrMsg); 631 EXPECT_EQ(batchSphFrameAnimationDataResult.values_size(), 1); 632 EXPECT_TRUE(batchSphFrameAnimationDataResult.values(0).has_frame_animation_data()); 633 EXPECT_EQ(batchSphFrameAnimationDataResult.values(0).frame_animation_data().animation_id(), ANIMATION_ID); 634 EXPECT_EQ(batchSphFrameAnimationDataResult.values(0).frame_animation_data().status(), STATUS); 635 EXPECT_EQ(batchSphFrameAnimationDataResult.values(0).frame_animation_data().start_ts(), START_TS); 636 EXPECT_EQ(batchSphFrameAnimationDataResult.values(0).frame_animation_data().end_ts(), END_TS); 637 EXPECT_EQ(batchSphFrameAnimationDataResult.values(0).frame_animation_data().name(), NAME); 638 } 639 640 /** 641 * @tc.name: ParseBatchSphDataWithSphFrameDynamicData 642 * @tc.desc: Parse a BatchSphData with SphFrameDynamicData 643 * @tc.type: FUNC 644 */ 645 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphFrameDynamicData, TestSize.Level1) 646 { 647 TS_LOGI("test42-17"); 648 649 BatchSphData batchSphFrameDynamicData; 650 auto sphFrameDynamicData = batchSphFrameDynamicData.add_values()->mutable_frame_dynamic_data(); 651 sphFrameDynamicData->set_id(ID); 652 sphFrameDynamicData->set_x(X); 653 sphFrameDynamicData->set_y(Y); 654 sphFrameDynamicData->set_width(WIDTH); 655 sphFrameDynamicData->set_height(HEIGHT); 656 sphFrameDynamicData->set_alpha(ALPHA); 657 sphFrameDynamicData->set_ts(TS); 658 sphFrameDynamicData->set_app_name(APP_NAME); 659 660 std::string sphStrMsg = ""; 661 batchSphFrameDynamicData.SerializeToString(&sphStrMsg); 662 BatchSphData batchSphFrameDynamicDataResult; 663 batchSphFrameDynamicDataResult.ParseFromString(sphStrMsg); 664 EXPECT_EQ(batchSphFrameDynamicDataResult.values_size(), 1); 665 EXPECT_TRUE(batchSphFrameDynamicDataResult.values(0).has_frame_dynamic_data()); 666 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().id(), ID); 667 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().x(), X); 668 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().y(), Y); 669 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().width(), WIDTH); 670 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().height(), HEIGHT); 671 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().alpha(), ALPHA); 672 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().ts(), TS); 673 EXPECT_EQ(batchSphFrameDynamicDataResult.values(0).frame_dynamic_data().app_name(), APP_NAME); 674 } 675 676 /** 677 * @tc.name: ParseBatchSphDataWithSphFrameSpacingData 678 * @tc.desc: Parse a BatchSphData with SphFrameSpacingData 679 * @tc.type: FUNC 680 */ 681 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphFrameSpacingData, TestSize.Level1) 682 { 683 TS_LOGI("test42-18"); 684 685 BatchSphData batchSphFrameSpacingData; 686 auto sphFrameSpacingData = batchSphFrameSpacingData.add_values()->mutable_frame_spacing_data(); 687 sphFrameSpacingData->set_id(ID); 688 sphFrameSpacingData->set_x(X); 689 sphFrameSpacingData->set_y(Y); 690 sphFrameSpacingData->set_current_frame_width(CURRENT_FRAME_WIDTH); 691 sphFrameSpacingData->set_current_frame_height(CURRENT_FRAME_HEIGHT); 692 sphFrameSpacingData->set_current_ts(CURRENT_TS); 693 sphFrameSpacingData->set_name_id(NAME_ID); 694 695 std::string sphStrMsg = ""; 696 batchSphFrameSpacingData.SerializeToString(&sphStrMsg); 697 BatchSphData batchSphFrameSpacingDataResult; 698 batchSphFrameSpacingDataResult.ParseFromString(sphStrMsg); 699 EXPECT_EQ(batchSphFrameSpacingDataResult.values_size(), 1); 700 EXPECT_TRUE(batchSphFrameSpacingDataResult.values(0).has_frame_spacing_data()); 701 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().id(), ID); 702 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().x(), X); 703 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().y(), Y); 704 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().current_frame_width(), CURRENT_FRAME_WIDTH); 705 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().current_frame_height(), 706 CURRENT_FRAME_HEIGHT); 707 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().current_ts(), CURRENT_TS); 708 EXPECT_EQ(batchSphFrameSpacingDataResult.values(0).frame_spacing_data().name_id(), NAME_ID); 709 } 710 711 /** 712 * @tc.name: ParseBatchSphDataWithSphEbpfData 713 * @tc.desc: Parse a BatchSphData with SphEbpfData 714 * @tc.type: FUNC 715 */ 716 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphEbpfData, TestSize.Level1) 717 { 718 TS_LOGI("test42-19"); 719 720 BatchSphData batchSphEbpfData; 721 auto sphSphEbpfData = batchSphEbpfData.add_values()->mutable_ebpf_data(); 722 sphSphEbpfData->set_start_ns(START_NS); 723 sphSphEbpfData->set_end_ns(END_NS); 724 sphSphEbpfData->set_dur(DUR); 725 726 std::string sphStrMsg = ""; 727 batchSphEbpfData.SerializeToString(&sphStrMsg); 728 BatchSphData batchSphEbpfDataResult; 729 batchSphEbpfDataResult.ParseFromString(sphStrMsg); 730 EXPECT_EQ(batchSphEbpfDataResult.values_size(), 1); 731 EXPECT_TRUE(batchSphEbpfDataResult.values(0).has_ebpf_data()); 732 EXPECT_EQ(batchSphEbpfDataResult.values(0).ebpf_data().start_ns(), START_NS); 733 EXPECT_EQ(batchSphEbpfDataResult.values(0).ebpf_data().end_ns(), END_NS); 734 EXPECT_EQ(batchSphEbpfDataResult.values(0).ebpf_data().dur(), DUR); 735 } 736 737 /** 738 * @tc.name: ParseBatchSphDataWithSphTrackerData 739 * @tc.desc: Parse a BatchSphData with SphTrackerData 740 * @tc.type: FUNC 741 */ 742 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphTrackerData, TestSize.Level1) 743 { 744 TS_LOGI("test42-20"); 745 746 BatchSphData batchSphTrackerData; 747 auto sphSphTrackerData = batchSphTrackerData.add_values()->mutable_tracker_data(); 748 sphSphTrackerData->set_start_ns(START_NS); 749 sphSphTrackerData->set_value(VALUE); 750 751 std::string sphStrMsg = ""; 752 batchSphTrackerData.SerializeToString(&sphStrMsg); 753 BatchSphData batchSphTrackerDataResult; 754 batchSphTrackerDataResult.ParseFromString(sphStrMsg); 755 EXPECT_EQ(batchSphTrackerDataResult.values_size(), 1); 756 EXPECT_TRUE(batchSphTrackerDataResult.values(0).has_tracker_data()); 757 EXPECT_EQ(batchSphTrackerDataResult.values(0).tracker_data().start_ns(), START_NS); 758 EXPECT_EQ(batchSphTrackerDataResult.values(0).tracker_data().value(), VALUE); 759 } 760 761 /** 762 * @tc.name: ParseBatchSphDataWithSphAbilityData 763 * @tc.desc: Parse a BatchSphData with SphAbilityData 764 * @tc.type: FUNC 765 */ 766 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphAbilityData, TestSize.Level1) 767 { 768 TS_LOGI("test42-21"); 769 770 BatchSphData batchSphAbilityData; 771 auto sphSphAbilityData = batchSphAbilityData.add_values()->mutable_ability_data(); 772 sphSphAbilityData->set_value(VALUE); 773 sphSphAbilityData->set_start_ns(START_NS); 774 sphSphAbilityData->set_dur(DUR); 775 776 std::string sphStrMsg = ""; 777 batchSphAbilityData.SerializeToString(&sphStrMsg); 778 BatchSphData batchSphAbilityDataResult; 779 batchSphAbilityDataResult.ParseFromString(sphStrMsg); 780 EXPECT_EQ(batchSphAbilityDataResult.values_size(), 1); 781 EXPECT_TRUE(batchSphAbilityDataResult.values(0).has_ability_data()); 782 EXPECT_EQ(batchSphAbilityDataResult.values(0).ability_data().value(), VALUE); 783 EXPECT_EQ(batchSphAbilityDataResult.values(0).ability_data().start_ns(), START_NS); 784 EXPECT_EQ(batchSphAbilityDataResult.values(0).ability_data().dur(), DUR); 785 } 786 787 /** 788 * @tc.name: ParseBatchSphDataWithSphProcessThreadData 789 * @tc.desc: Parse a BatchSphData with SphProcessThreadData 790 * @tc.type: FUNC 791 */ 792 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessThreadData, TestSize.Level1) 793 { 794 TS_LOGI("test42-22"); 795 796 BatchSphData batchSphProcessThreadData; 797 auto sphProcessThreadData = batchSphProcessThreadData.add_values()->mutable_process_thread_data(); 798 sphProcessThreadData->set_cpu(CPU); 799 sphProcessThreadData->set_dur(DUR); 800 sphProcessThreadData->set_id(ID); 801 sphProcessThreadData->set_tid(TID); 802 sphProcessThreadData->set_state(STATE); 803 sphProcessThreadData->set_pid(PID); 804 sphProcessThreadData->set_start_time(START_TIME); 805 sphProcessThreadData->set_arg_set_id(ARG_SET_ID); 806 807 std::string sphStrMsg = ""; 808 batchSphProcessThreadData.SerializeToString(&sphStrMsg); 809 BatchSphData batchSphProcessThreadDataResult; 810 batchSphProcessThreadDataResult.ParseFromString(sphStrMsg); 811 EXPECT_EQ(batchSphProcessThreadDataResult.values_size(), 1); 812 EXPECT_TRUE(batchSphProcessThreadDataResult.values(0).has_process_thread_data()); 813 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().cpu(), CPU); 814 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().dur(), DUR); 815 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().id(), ID); 816 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().tid(), TID); 817 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().state(), STATE); 818 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().pid(), PID); 819 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().start_time(), START_TIME); 820 EXPECT_EQ(batchSphProcessThreadDataResult.values(0).process_thread_data().arg_set_id(), ARG_SET_ID); 821 } 822 823 /** 824 * @tc.name: ParseBatchSphDataWithSphProcessFuncData 825 * @tc.desc: Parse a BatchSphData with SphProcessFuncData 826 * @tc.type: FUNC 827 */ 828 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphProcessFuncData, TestSize.Level1) 829 { 830 TS_LOGI("test42-23"); 831 832 BatchSphData batchSphProcessFuncData; 833 auto sphProcessFuncData = batchSphProcessFuncData.add_values()->mutable_process_func_data(); 834 sphProcessFuncData->set_start_ts(START_TS); 835 sphProcessFuncData->set_dur(DUR); 836 sphProcessFuncData->set_argsetid(ARGSETTID); 837 sphProcessFuncData->set_depth(DEPTH); 838 sphProcessFuncData->set_id(ID); 839 sphProcessFuncData->set_itid(ITID); 840 sphProcessFuncData->set_ipid(IPID); 841 842 std::string sphStrMsg = ""; 843 batchSphProcessFuncData.SerializeToString(&sphStrMsg); 844 BatchSphData batchSphProcessFuncDataRes; 845 batchSphProcessFuncDataRes.ParseFromString(sphStrMsg); 846 EXPECT_EQ(batchSphProcessFuncDataRes.values_size(), 1); 847 EXPECT_TRUE(batchSphProcessFuncDataRes.values(0).has_process_func_data()); 848 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().start_ts(), START_TS); 849 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().dur(), DUR); 850 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().argsetid(), ARGSETTID); 851 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().depth(), DEPTH); 852 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().id(), ID); 853 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().itid(), ITID); 854 EXPECT_EQ(batchSphProcessFuncDataRes.values(0).process_func_data().ipid(), IPID); 855 } 856 857 /** 858 * @tc.name: ParseBatchSphDataWithSphHiperfData 859 * @tc.desc: Parse a BatchSphData with SphHiperfData 860 * @tc.type: FUNC 861 */ 862 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphWithSphHiperfData, TestSize.Level1) 863 { 864 TS_LOGI("test42-24"); 865 866 BatchSphData batchSphHiperfData; 867 auto sphHiperfData = batchSphHiperfData.add_values()->mutable_hiperf_data(); 868 sphHiperfData->set_start_ns(START_NS); 869 sphHiperfData->set_event_count(EVENT_COUNT); 870 sphHiperfData->set_sample_count(SAMPLE_COUNT); 871 sphHiperfData->set_event_type_id(EVENT_TYPE_ID); 872 sphHiperfData->set_callchain_id(CALLCHAIN_ID); 873 874 std::string sphStrMsg = ""; 875 batchSphHiperfData.SerializeToString(&sphStrMsg); 876 BatchSphData batchSphHiperfDataResult; 877 batchSphHiperfDataResult.ParseFromString(sphStrMsg); 878 EXPECT_EQ(batchSphHiperfDataResult.values_size(), 1); 879 EXPECT_TRUE(batchSphHiperfDataResult.values(0).has_hiperf_data()); 880 EXPECT_EQ(batchSphHiperfDataResult.values(0).hiperf_data().start_ns(), START_NS); 881 EXPECT_EQ(batchSphHiperfDataResult.values(0).hiperf_data().event_count(), EVENT_COUNT); 882 EXPECT_EQ(batchSphHiperfDataResult.values(0).hiperf_data().sample_count(), SAMPLE_COUNT); 883 EXPECT_EQ(batchSphHiperfDataResult.values(0).hiperf_data().event_type_id(), EVENT_TYPE_ID); 884 EXPECT_EQ(batchSphHiperfDataResult.values(0).hiperf_data().callchain_id(), CALLCHAIN_ID); 885 } 886 887 /** 888 * @tc.name: ParseBatchSphHiperfCallChartData 889 * @tc.desc: Parse a BatchSphData with SphHiperfCallChartData 890 * @tc.type: FUNC 891 */ 892 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphHiperfCallChartData, TestSize.Level1) 893 { 894 TS_LOGI("test42-25"); 895 896 BatchSphData batchSphHiperfCallChartData; 897 auto sphHiperfCallChartData = batchSphHiperfCallChartData.add_values()->mutable_hiperf_call_chart_data(); 898 sphHiperfCallChartData->set_callchain_id(CALLCHAIN_ID); 899 sphHiperfCallChartData->set_start_ts(START_TS); 900 sphHiperfCallChartData->set_event_count(EVENT_COUNT); 901 sphHiperfCallChartData->set_thread_id(THREAD_ID); 902 sphHiperfCallChartData->set_cpu_id(CPU_ID); 903 sphHiperfCallChartData->set_event_type_id(EVENT_TYPE_ID); 904 905 std::string sphStrMsg = ""; 906 batchSphHiperfCallChartData.SerializeToString(&sphStrMsg); 907 BatchSphData batchSphHperfCallChartDataResult; 908 batchSphHperfCallChartDataResult.ParseFromString(sphStrMsg); 909 EXPECT_EQ(batchSphHperfCallChartDataResult.values_size(), 1); 910 EXPECT_TRUE(batchSphHperfCallChartDataResult.values(0).has_hiperf_call_chart_data()); 911 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().callchain_id(), CALLCHAIN_ID); 912 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().start_ts(), START_TS); 913 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().event_count(), EVENT_COUNT); 914 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().thread_id(), THREAD_ID); 915 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().cpu_id(), CPU_ID); 916 EXPECT_EQ(batchSphHperfCallChartDataResult.values(0).hiperf_call_chart_data().event_type_id(), EVENT_TYPE_ID); 917 } 918 919 /** 920 * @tc.name: ParseBatchSphHiperfCallStackData 921 * @tc.desc: Parse a BatchSphData with SphHiperfCallStackData 922 * @tc.type: FUNC 923 */ 924 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphHiperfCallStackData, TestSize.Level1) 925 { 926 TS_LOGI("test42-26"); 927 928 BatchSphData batchSphHiperfCallStackData; 929 auto sphHiperfCallStackData = batchSphHiperfCallStackData.add_values()->mutable_hiperf_call_stack_data(); 930 sphHiperfCallStackData->set_callchain_id(CALLCHAIN_ID); 931 sphHiperfCallStackData->set_file_id(FILE_ID); 932 sphHiperfCallStackData->set_depth(DEPTH); 933 sphHiperfCallStackData->set_symbol_id(SYMBOL_ID); 934 935 std::string sphStrMsg = ""; 936 batchSphHiperfCallStackData.SerializeToString(&sphStrMsg); 937 BatchSphData batchSphHiperfCallStackDataResult; 938 batchSphHiperfCallStackDataResult.ParseFromString(sphStrMsg); 939 EXPECT_EQ(batchSphHiperfCallStackDataResult.values_size(), 1); 940 EXPECT_TRUE(batchSphHiperfCallStackDataResult.values(0).has_hiperf_call_stack_data()); 941 EXPECT_EQ(batchSphHiperfCallStackDataResult.values(0).hiperf_call_stack_data().callchain_id(), CALLCHAIN_ID); 942 EXPECT_EQ(batchSphHiperfCallStackDataResult.values(0).hiperf_call_stack_data().file_id(), FILE_ID); 943 EXPECT_EQ(batchSphHiperfCallStackDataResult.values(0).hiperf_call_stack_data().depth(), DEPTH); 944 EXPECT_EQ(batchSphHiperfCallStackDataResult.values(0).hiperf_call_stack_data().symbol_id(), SYMBOL_ID); 945 } 946 947 /** 948 * @tc.name: ParseBatchSphProcessJanksFramesData 949 * @tc.desc: Parse a BatchSphData with SphProcessJanksFramesData 950 * @tc.type: FUNC 951 */ 952 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphProcessJanksFramesData, TestSize.Level1) 953 { 954 TS_LOGI("test42-27"); 955 956 BatchSphData batchSphProcessJanksFramesData; 957 auto sphProcessJanksFramesData = batchSphProcessJanksFramesData.add_values()->mutable_process_janks_frames_data(); 958 sphProcessJanksFramesData->set_ts(TS); 959 sphProcessJanksFramesData->set_dur(DUR); 960 sphProcessJanksFramesData->set_pid(PID); 961 sphProcessJanksFramesData->set_id(ID); 962 sphProcessJanksFramesData->set_name(INT_NAME); 963 sphProcessJanksFramesData->set_type(INT_TYPE); 964 965 std::string sphStrMsg = ""; 966 batchSphProcessJanksFramesData.SerializeToString(&sphStrMsg); 967 BatchSphData batchSphProcessJanksFramesRes; 968 batchSphProcessJanksFramesRes.ParseFromString(sphStrMsg); 969 EXPECT_EQ(batchSphProcessJanksFramesRes.values_size(), 1); 970 EXPECT_TRUE(batchSphProcessJanksFramesRes.values(0).has_process_janks_frames_data()); 971 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().ts(), TS); 972 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().dur(), DUR); 973 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().pid(), PID); 974 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().name(), INT_NAME); 975 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().type(), INT_TYPE); 976 } 977 978 /** 979 * @tc.name: ParseBatchSphProcessJanksFrames 980 * @tc.desc: Parse a BatchSphData with SphProcessJanksFrames 981 * @tc.type: FUNC 982 */ 983 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphProcessJanksFrames, TestSize.Level1) 984 { 985 TS_LOGI("test42-28"); 986 987 BatchSphData batchSphProcessJanksFramesData; 988 auto sphProcessJanksFramesData = batchSphProcessJanksFramesData.add_values()->mutable_process_janks_frames_data(); 989 sphProcessJanksFramesData->set_ts(TS); 990 sphProcessJanksFramesData->set_dur(DUR); 991 sphProcessJanksFramesData->set_pid(PID); 992 sphProcessJanksFramesData->set_id(ID); 993 sphProcessJanksFramesData->set_name(INT_NAME); 994 sphProcessJanksFramesData->set_type(INT_TYPE); 995 996 std::string sphStrMsg = ""; 997 batchSphProcessJanksFramesData.SerializeToString(&sphStrMsg); 998 BatchSphData batchSphProcessJanksFramesRes; 999 batchSphProcessJanksFramesRes.ParseFromString(sphStrMsg); 1000 EXPECT_EQ(batchSphProcessJanksFramesRes.values_size(), 1); 1001 EXPECT_TRUE(batchSphProcessJanksFramesRes.values(0).has_process_janks_frames_data()); 1002 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().ts(), TS); 1003 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().dur(), DUR); 1004 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().pid(), PID); 1005 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().id(), ID); 1006 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().name(), INT_NAME); 1007 EXPECT_EQ(batchSphProcessJanksFramesRes.values(0).process_janks_frames_data().type(), INT_TYPE); 1008 } 1009 1010 /** 1011 * @tc.name: ParseBatchSphProcessInputEventData 1012 * @tc.desc: Parse a BatchSphData with SphProcessInputEventData 1013 * @tc.type: FUNC 1014 */ 1015 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphProcessInputEventData, TestSize.Level1) 1016 { 1017 TS_LOGI("test42-29"); 1018 1019 BatchSphData batchSphProcessInputEventData; 1020 auto sphProcessInputEventData = batchSphProcessInputEventData.add_values()->mutable_process_input_event_data(); 1021 sphProcessInputEventData->set_start_ts(START_TS); 1022 sphProcessInputEventData->set_dur(DUR); 1023 sphProcessInputEventData->set_argsetid(ARGSETTID); 1024 sphProcessInputEventData->set_tid(TID); 1025 sphProcessInputEventData->set_pid(PID); 1026 sphProcessInputEventData->set_is_main_thread(IS_MAIN_THREAD); 1027 sphProcessInputEventData->set_track_id(TRACK_ID); 1028 sphProcessInputEventData->set_parent_id(PARENT_ID); 1029 sphProcessInputEventData->set_id(ID); 1030 sphProcessInputEventData->set_cookie(COOKIE); 1031 sphProcessInputEventData->set_depth(DEPTH); 1032 1033 std::string sphStrMsg = ""; 1034 batchSphProcessInputEventData.SerializeToString(&sphStrMsg); 1035 BatchSphData batchProcessInputEventFramesRes; 1036 batchProcessInputEventFramesRes.ParseFromString(sphStrMsg); 1037 EXPECT_EQ(batchProcessInputEventFramesRes.values_size(), 1); 1038 EXPECT_TRUE(batchProcessInputEventFramesRes.values(0).has_process_input_event_data()); 1039 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().start_ts(), START_TS); 1040 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().dur(), DUR); 1041 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().argsetid(), ARGSETTID); 1042 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().tid(), TID); 1043 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().pid(), PID); 1044 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().is_main_thread(), IS_MAIN_THREAD); 1045 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().id(), ID); 1046 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().cookie(), COOKIE); 1047 EXPECT_EQ(batchProcessInputEventFramesRes.values(0).process_input_event_data().depth(), DEPTH); 1048 } 1049 1050 /** 1051 * @tc.name: ParseBatchSphHeapFilesData 1052 * @tc.desc: Parse a BatchSphData with SphHeapFilesData 1053 * @tc.type: FUNC 1054 */ 1055 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphHeapFilesData, TestSize.Level1) 1056 { 1057 TS_LOGI("test42-30"); 1058 1059 BatchSphData batchSphHeapFilesData; 1060 auto sphHeapFilesData = batchSphHeapFilesData.add_values()->mutable_heap_files_data(); 1061 sphHeapFilesData->set_id(ID); 1062 sphHeapFilesData->set_name(NAME); 1063 sphHeapFilesData->set_start_ts(START_TS); 1064 sphHeapFilesData->set_end_ts(END_TS); 1065 sphHeapFilesData->set_size(SIZE); 1066 sphHeapFilesData->set_pid(PID); 1067 1068 std::string sphStrMsg = ""; 1069 batchSphHeapFilesData.SerializeToString(&sphStrMsg); 1070 BatchSphData batchHeapFilesDataFramesRes; 1071 batchHeapFilesDataFramesRes.ParseFromString(sphStrMsg); 1072 EXPECT_EQ(batchHeapFilesDataFramesRes.values_size(), 1); 1073 EXPECT_TRUE(batchHeapFilesDataFramesRes.values(0).has_heap_files_data()); 1074 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().id(), ID); 1075 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().name(), NAME); 1076 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().start_ts(), START_TS); 1077 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().end_ts(), END_TS); 1078 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().size(), SIZE); 1079 EXPECT_EQ(batchHeapFilesDataFramesRes.values(0).heap_files_data().pid(), PID); 1080 } 1081 1082 /** 1083 * @tc.name: ParseBatchSphCpuProfilerData 1084 * @tc.desc: Parse a BatchSphData with SphCpuProfilerData 1085 * @tc.type: FUNC 1086 */ 1087 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphCpuProfilerData, TestSize.Level1) 1088 { 1089 TS_LOGI("test42-31"); 1090 1091 BatchSphData batchSphCpuProfilerData; 1092 auto sphCpuProfilerData = batchSphCpuProfilerData.add_values()->mutable_cpu_profiler_data(); 1093 sphCpuProfilerData->set_id(ID); 1094 sphCpuProfilerData->set_function_id(FUNCTION_ID); 1095 sphCpuProfilerData->set_start_time(START_TIME); 1096 sphCpuProfilerData->set_end_time(END_TIME); 1097 sphCpuProfilerData->set_dur(DUR); 1098 sphCpuProfilerData->set_name_id(INT_NAME_ID); 1099 sphCpuProfilerData->set_url_id(URL_ID); 1100 sphCpuProfilerData->set_line(LINE); 1101 sphCpuProfilerData->set_column(COLUMN); 1102 sphCpuProfilerData->set_hit_count(HIT_COUNT); 1103 sphCpuProfilerData->set_children_string(CHILDREN_STRING); 1104 sphCpuProfilerData->set_parent_id(PARENT_ID); 1105 1106 std::string sphStrMsg = ""; 1107 batchSphCpuProfilerData.SerializeToString(&sphStrMsg); 1108 BatchSphData batchCpuProfilerDataRes; 1109 batchCpuProfilerDataRes.ParseFromString(sphStrMsg); 1110 EXPECT_EQ(batchCpuProfilerDataRes.values_size(), 1); 1111 EXPECT_TRUE(batchCpuProfilerDataRes.values(0).has_cpu_profiler_data()); 1112 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().id(), ID); 1113 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().function_id(), FUNCTION_ID); 1114 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().start_time(), START_TIME); 1115 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().end_time(), END_TIME); 1116 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().dur(), DUR); 1117 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().name_id(), INT_NAME_ID); 1118 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().url_id(), URL_ID); 1119 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().line(), LINE); 1120 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().column(), COLUMN); 1121 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().hit_count(), HIT_COUNT); 1122 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().children_string(), CHILDREN_STRING); 1123 EXPECT_EQ(batchCpuProfilerDataRes.values(0).cpu_profiler_data().parent_id(), PARENT_ID); 1124 } 1125 1126 /** 1127 * @tc.name: ParseBatchSphNativeMemoryNormalData 1128 * @tc.desc: Parse a BatchSphData with SphNativeMemoryNormalData 1129 * @tc.type: FUNC 1130 */ 1131 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphNativeMemoryNormalData, TestSize.Level1) 1132 { 1133 TS_LOGI("test42-32"); 1134 1135 BatchSphData batchSphNativMemoryNormalData; 1136 auto sphNativMemoryNormalData = batchSphNativMemoryNormalData.add_values()->mutable_native_memory_normal(); 1137 sphNativMemoryNormalData->set_start_time(START_TIME); 1138 sphNativMemoryNormalData->set_heap_size(HEAP_SIZE); 1139 sphNativMemoryNormalData->set_event_type(EVENT_TYPE); 1140 sphNativMemoryNormalData->set_ipid(IPID); 1141 1142 std::string sphStrMsg = ""; 1143 batchSphNativMemoryNormalData.SerializeToString(&sphStrMsg); 1144 BatchSphData batchNativMemoryNormalDataRes; 1145 batchNativMemoryNormalDataRes.ParseFromString(sphStrMsg); 1146 EXPECT_EQ(batchNativMemoryNormalDataRes.values_size(), 1); 1147 EXPECT_TRUE(batchNativMemoryNormalDataRes.values(0).has_native_memory_normal()); 1148 EXPECT_EQ(batchNativMemoryNormalDataRes.values(0).native_memory_normal().start_time(), START_TIME); 1149 EXPECT_EQ(batchNativMemoryNormalDataRes.values(0).native_memory_normal().heap_size(), HEAP_SIZE); 1150 EXPECT_EQ(batchNativMemoryNormalDataRes.values(0).native_memory_normal().event_type(), EVENT_TYPE); 1151 EXPECT_EQ(batchNativMemoryNormalDataRes.values(0).native_memory_normal().ipid(), IPID); 1152 } 1153 1154 /** 1155 * @tc.name: ParseBatchSphNativeMemoryStatisticData 1156 * @tc.desc: Parse a BatchSphData with SphNativeMemoryStatisticData 1157 * @tc.type: FUNC 1158 */ 1159 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphNativeMemoryStatisticData, TestSize.Level1) 1160 { 1161 TS_LOGI("test42-33"); 1162 1163 BatchSphData batchSphNatMemStatisticData; 1164 auto sphNatMemStatisticData = batchSphNatMemStatisticData.add_values()->mutable_native_memory_statistic(); 1165 sphNatMemStatisticData->set_callchain_id(CALLCHAIN_ID); 1166 sphNatMemStatisticData->set_start_ts(START_TS); 1167 sphNatMemStatisticData->set_apply_count(APPLY_COUNT); 1168 sphNatMemStatisticData->set_apply_size(APPLY_SIZE); 1169 sphNatMemStatisticData->set_release_count(RELEASE_COUNT); 1170 sphNatMemStatisticData->set_release_size(RELEASE_SIZE); 1171 sphNatMemStatisticData->set_ipid(IPID); 1172 sphNatMemStatisticData->set_type(INT_TYPE); 1173 1174 std::string sphStrMsg = ""; 1175 batchSphNatMemStatisticData.SerializeToString(&sphStrMsg); 1176 BatchSphData batchNatMemStatisticDataRes; 1177 batchNatMemStatisticDataRes.ParseFromString(sphStrMsg); 1178 EXPECT_EQ(batchNatMemStatisticDataRes.values_size(), 1); 1179 EXPECT_TRUE(batchNatMemStatisticDataRes.values(0).has_native_memory_statistic()); 1180 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().callchain_id(), CALLCHAIN_ID); 1181 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().start_ts(), START_TS); 1182 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().apply_count(), APPLY_COUNT); 1183 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().apply_size(), APPLY_SIZE); 1184 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().release_count(), RELEASE_COUNT); 1185 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().release_size(), RELEASE_SIZE); 1186 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().ipid(), IPID); 1187 EXPECT_EQ(batchNatMemStatisticDataRes.values(0).native_memory_statistic().type(), INT_TYPE); 1188 } 1189 1190 /** 1191 * @tc.name: ParseBatchSphCpuAbilityData 1192 * @tc.desc: Parse a BatchSphData with SphCpuAbilityData 1193 * @tc.type: FUNC 1194 */ 1195 HWTEST_F(SqllitePreparCacheDataTest, ParseBatchSphCpuAbilityData, TestSize.Level1) 1196 { 1197 TS_LOGI("test42-34"); 1198 1199 BatchSphData batchSphCpuAbilityData; 1200 auto sphCpuAbilityData = batchSphCpuAbilityData.add_values()->mutable_cpu_ability_data(); 1201 sphCpuAbilityData->set_value(SVALUE); 1202 sphCpuAbilityData->set_start_ns(START_NS); 1203 sphCpuAbilityData->set_dur(DUR); 1204 1205 std::string sphStrMsg = ""; 1206 batchSphCpuAbilityData.SerializeToString(&sphStrMsg); 1207 BatchSphData batchsphCpuAbilityDataRes; 1208 batchsphCpuAbilityDataRes.ParseFromString(sphStrMsg); 1209 EXPECT_EQ(batchsphCpuAbilityDataRes.values_size(), 1); 1210 EXPECT_TRUE(batchsphCpuAbilityDataRes.values(0).has_cpu_ability_data()); 1211 EXPECT_EQ(batchsphCpuAbilityDataRes.values(0).cpu_ability_data().value(), SVALUE); 1212 EXPECT_EQ(batchsphCpuAbilityDataRes.values(0).cpu_ability_data().start_ns(), START_NS); 1213 EXPECT_EQ(batchsphCpuAbilityDataRes.values(0).cpu_ability_data().dur(), DUR); 1214 } 1215 } // namespace SqlitePreparCacheUnitTest 1216 } // namespace TraceStreamer 1217 } // namespace SysTuning 1218