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