1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 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 <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 19 #include "htrace_mem_parser.h" 20 #include "rpc_server.h" 21 #include "trace_data_cache.h" 22 #include "trace_streamer_selector.h" 23 24 using namespace testing::ext; 25 using namespace SysTuning::TraceStreamer; 26 namespace SysTuning { 27 namespace TraceStreamer { 28 class TableTest : public ::testing::Test { 29 public: SetUp()30 void SetUp() 31 { 32 stream_.InitFilter(); 33 } TearDown()34 void TearDown() {} 35 36 public: 37 TraceStreamerSelector stream_ = {}; 38 }; 39 40 /** 41 * @tc.name: AppnameTableTest 42 * @tc.desc: Appname Table Test 43 * @tc.type: FUNC 44 */ 45 HWTEST_F(TableTest, AppnameTableTest, TestSize.Level1) 46 { 47 TS_LOGI("test31-1"); 48 std::string sqlSelect = "select * from app_name"; 49 uint8_t flags = 0; 50 DataIndex eventSource = stream_.traceDataCache_->GetDataIndex("eventSource"); 51 DataIndex appName = stream_.traceDataCache_->GetDataIndex("app1"); 52 stream_.traceDataCache_->GetAppNamesData()->AppendAppName(flags, eventSource, appName); 53 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 54 EXPECT_EQ(row, 1); 55 } 56 /** 57 * @tc.name: ArgsTableTest 58 * @tc.desc: Args Table Test 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(TableTest, ArgsTableTest, TestSize.Level1) 62 { 63 TS_LOGI("test31-2"); 64 std::string sqlSelect = "select * from args"; 65 std::string sqlSelect1 = "select * from args where id = 1"; 66 std::string sqlSelect2 = "select * from args where key > 1"; 67 std::string sqlSelect3 = "select * from args where id < 1"; 68 std::string sqlSelect4 = "select * from args where id >= 1"; 69 std::string sqlSelect5 = "select * from args where id <= 1"; 70 DataIndex nameId0 = stream_.traceDataCache_->GetDataIndex("args0"); 71 DataIndex nameId1 = stream_.traceDataCache_->GetDataIndex("args1"); 72 BaseDataType dataType0 = BASE_DATA_TYPE_INT; 73 BaseDataType dataType1 = BASE_DATA_TYPE_STRING; 74 int64_t value0 = 123; 75 int64_t value1 = 456; 76 size_t argSet0 = 321; 77 size_t argSet1 = 654; 78 stream_.traceDataCache_->InitDB(); 79 stream_.traceDataCache_->GetArgSetData()->AppendNewArg(nameId0, dataType0, value0, argSet0); 80 stream_.traceDataCache_->GetArgSetData()->AppendNewArg(nameId1, dataType1, value1, argSet1); 81 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 82 EXPECT_EQ(row, 2); 83 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 84 EXPECT_EQ(row, 1); 85 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 86 EXPECT_EQ(row, 2); 87 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 88 EXPECT_EQ(row, 1); 89 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 90 EXPECT_EQ(row, 1); 91 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 92 EXPECT_EQ(row, 2); 93 } 94 /** 95 * @tc.name: CallstackTableTest 96 * @tc.desc: Callstack Table Test 97 * @tc.type: FUNC 98 */ 99 HWTEST_F(TableTest, CallstackTableTest, TestSize.Level1) 100 { 101 TS_LOGI("test31-3"); 102 std::string sqlSelect = "select * from callstack"; 103 std::string sqlSelect1 = "select * from callstack where id = 1"; 104 std::string sqlSelect2 = "select * from callstack where ts > 1"; 105 std::string sqlSelect3 = "select * from callstack where callid < 1"; 106 std::string sqlSelect4 = "select * from callstack where cookie >= 1"; 107 std::string sqlSelect5 = "select * from callstack where cookie <= 1"; 108 uint64_t startT = 1; 109 uint64_t durationNs = 1; 110 InternalTid internalTid = 1; 111 DataIndex cat = stream_.traceDataCache_->GetDataIndex("callstack"); 112 uint16_t nameIdentify = 1; 113 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 114 uint8_t depth = 1; 115 uint64_t cookid = stream_.traceDataCache_->GetDataIndex("cook"); 116 const std::optional<uint64_t>& parentId = 1; 117 118 uint64_t startT1 = 1; 119 uint64_t durationNs1 = 1; 120 InternalTid internalTid1 = 1; 121 DataIndex cat1 = stream_.traceDataCache_->GetDataIndex("callstack1"); 122 uint16_t nameIdentify1 = 1; 123 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 124 uint8_t depth1 = 1; 125 uint64_t cookid1 = stream_.traceDataCache_->GetDataIndex("cook1"); 126 const std::optional<uint64_t>& parentId1 = 1; 127 128 stream_.traceDataCache_->InitDB(); 129 stream_.traceDataCache_->GetInternalSlicesData()->AppendInternalAsyncSlice( 130 startT, durationNs, internalTid, cat, nameIdentify, name, depth, cookid, parentId); 131 stream_.traceDataCache_->GetInternalSlicesData()->AppendInternalAsyncSlice( 132 startT1, durationNs1, internalTid1, cat1, nameIdentify1, name1, depth1, cookid1, parentId1); 133 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 134 EXPECT_EQ(row, 2); 135 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 136 EXPECT_EQ(row, 1); 137 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 138 EXPECT_EQ(row, 0); 139 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 140 EXPECT_EQ(row, 0); 141 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 142 EXPECT_EQ(row, 0); 143 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 144 EXPECT_EQ(row, 0); 145 } 146 /** 147 * @tc.name: ClkEventFilterTableTest 148 * @tc.desc: ClkEvent filter table test 149 * @tc.type: FUNC 150 */ 151 HWTEST_F(TableTest, ClkEventFilterTableTest, TestSize.Level1) 152 { 153 TS_LOGI("test31-4"); 154 std::string sqlSelect = "select * from clk_event_filter"; 155 std::string sqlSelect1 = "select * from clk_event_filter where id = 1"; 156 std::string sqlSelect2 = "select * from clk_event_filter where name < 0"; 157 std::string sqlSelect3 = "select * from clk_event_filter where id > 0"; 158 std::string sqlSelect4 = "select * from clk_event_filter where id >= 0"; 159 std::string sqlSelect5 = "select * from clk_event_filter where id <= 0"; 160 uint64_t id = 1; 161 uint64_t rate = 1; 162 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 163 uint64_t cpu = 1; 164 165 uint64_t id1 = 1; 166 uint64_t rate1 = 0; 167 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 168 uint64_t cpu1 = 1; 169 stream_.traceDataCache_->GetClkEventFilterData()->AppendNewFilter(id, rate, name, cpu); 170 stream_.traceDataCache_->GetClkEventFilterData()->AppendNewFilter(id1, rate1, name1, cpu1); 171 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 172 EXPECT_EQ(row, 2); 173 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 174 EXPECT_EQ(row, 2); 175 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 176 EXPECT_EQ(row, 0); 177 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 178 EXPECT_EQ(row, 2); 179 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 180 EXPECT_EQ(row, 2); 181 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 182 EXPECT_EQ(row, 2); 183 } 184 /** 185 * @tc.name: ClockEventFilterTableTest 186 * @tc.desc: ClockEvent filter table test 187 * @tc.type: FUNC 188 */ 189 HWTEST_F(TableTest, ClockEventFilterTableTest, TestSize.Level1) 190 { 191 TS_LOGI("test31-5"); 192 std::string sqlSelect = "select * from clock_event_filter"; 193 std::string sqlSelect1 = "select * from clock_event_filter where id = 1"; 194 std::string sqlSelect2 = "select * from clock_event_filter where type > 1"; 195 std::string sqlSelect3 = "select * from clock_event_filter where name < 1"; 196 std::string sqlSelect4 = "select * from clock_event_filter where cpu >= 1"; 197 std::string sqlSelect5 = "select * from clock_event_filter where id <= 1"; 198 uint64_t id = 1; 199 uint64_t type = 1; 200 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 201 uint64_t cpu = 1; 202 203 uint64_t id1 = 1; 204 uint64_t type1 = 0; 205 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 206 uint64_t cpu1 = 1; 207 stream_.traceDataCache_->GetClockEventFilterData()->AppendNewFilter(id, type, name, cpu); 208 stream_.traceDataCache_->GetClockEventFilterData()->AppendNewFilter(id1, type1, name1, cpu1); 209 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 210 EXPECT_EQ(row, 2); 211 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 212 EXPECT_EQ(row, 2); 213 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 214 EXPECT_EQ(row, 1); 215 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 216 EXPECT_EQ(row, 0); 217 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 218 EXPECT_EQ(row, 2); 219 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 220 EXPECT_EQ(row, 2); 221 } 222 /** 223 * @tc.name: CpuMeasureFilterTableTest 224 * @tc.desc: Cpu measure filter table test 225 * @tc.type: FUNC 226 */ 227 HWTEST_F(TableTest, CpuMeasureFilterTableTest, TestSize.Level1) 228 { 229 TS_LOGI("test31-6"); 230 std::string sqlSelect = "select * from cpu_measure_filter"; 231 std::string sqlSelect1 = "select * from cpu_measure_filter where id = 1"; 232 std::string sqlSelect2 = "select * from cpu_measure_filter where id > 1"; 233 std::string sqlSelect3 = "select * from cpu_measure_filter where type < 1"; 234 std::string sqlSelect4 = "select * from cpu_measure_filter where name >= 1"; 235 std::string sqlSelect5 = "select * from cpu_measure_filter where cpu <= 1"; 236 uint64_t filterId = 2; 237 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 238 uint32_t cpu = 1; 239 240 uint64_t filterId1 = 1; 241 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 242 uint32_t cpu1 = 2; 243 244 stream_.traceDataCache_->GetCpuMeasuresData()->AppendNewFilter(filterId, name, cpu); 245 stream_.traceDataCache_->GetCpuMeasuresData()->AppendNewFilter(filterId1, name1, cpu1); 246 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 247 EXPECT_EQ(row, 2); 248 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 249 EXPECT_EQ(row, 2); 250 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 251 EXPECT_EQ(row, 0); 252 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 253 EXPECT_EQ(row, 0); 254 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 255 EXPECT_EQ(row, 2); 256 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 257 EXPECT_EQ(row, 1); 258 } 259 /** 260 * @tc.name: CpuUsageFilterTableTest 261 * @tc.desc: Cpu usage filter table test 262 * @tc.type: FUNC 263 */ 264 HWTEST_F(TableTest, CpuUsageFilterTableTest, TestSize.Level1) 265 { 266 TS_LOGI("test31-7"); 267 std::string sqlSelect = "select * from cpu_usage"; 268 uint64_t newTimeStamp = 1663869124160; 269 uint64_t dur = 560; 270 double totalLoad = 2; 271 double userLoad = 2; 272 double systemLoad = 2; 273 int64_t thread = 2; 274 275 uint64_t newTimeStamp1 = 1663869224160; 276 uint64_t dur1 = 550; 277 double totalLoad1 = 1; 278 double userLoad1 = 1; 279 double systemLoad1 = 1; 280 int64_t thread1 = 1; 281 282 stream_.traceDataCache_->GetCpuUsageInfoData()->AppendNewData(newTimeStamp, dur, totalLoad, userLoad, userLoad, 283 thread); 284 stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 285 stream_.traceDataCache_->GetCpuUsageInfoData()->AppendNewData(newTimeStamp1, dur1, totalLoad1, userLoad1, userLoad1, 286 thread1); 287 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 288 EXPECT_EQ(row, 2); 289 } 290 /** 291 * @tc.name: DataDictTableTest 292 * @tc.desc: Data dict table test 293 * @tc.type: FUNC 294 */ 295 HWTEST_F(TableTest, DataDictTableTest, TestSize.Level1) 296 { 297 TS_LOGI("test31-8"); 298 std::string sqlSelect = "select * from data_dict"; 299 std::string sqlSelect1 = "select * from data_dict where id = 1"; 300 std::string sqlSelect2 = "select * from data_dict where id > 1"; 301 std::string sqlSelect3 = "select * from data_dict where id < 1"; 302 std::string sqlSelect4 = "select * from data_dict where id >= 1"; 303 std::string sqlSelect5 = "select * from data_dict where data <= 1"; 304 stream_.traceDataCache_->GetDataFromDict(1); 305 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 306 EXPECT_EQ(row, 61); 307 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 308 EXPECT_EQ(row, 1); 309 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 310 EXPECT_EQ(row, 59); 311 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 312 EXPECT_EQ(row, 1); 313 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 314 EXPECT_EQ(row, 60); 315 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 316 EXPECT_EQ(row, 1); 317 } 318 /** 319 * @tc.name: DataTypeTableTest 320 * @tc.desc: Data type table test 321 * @tc.type: FUNC 322 */ 323 HWTEST_F(TableTest, DataTypeTableTest, TestSize.Level1) 324 { 325 TS_LOGI("test31-9"); 326 std::string sqlSelect = "select * from data_type"; 327 std::string sqlSelect1 = "select * from data_type where id = 1"; 328 std::string sqlSelect2 = "select * from data_type where id > 1"; 329 std::string sqlSelect3 = "select * from data_type where id < 1"; 330 std::string sqlSelect4 = "select * from data_type where typeId >= 1"; 331 std::string sqlSelect5 = "select * from data_type where id <= 1"; 332 BaseDataType dataType = BASE_DATA_TYPE_INT; 333 DataIndex dataDescIndex = stream_.traceDataCache_->GetDataIndex("dataDescIndex"); 334 BaseDataType dataType1 = BASE_DATA_TYPE_STRING; 335 DataIndex dataDescIndex1 = stream_.traceDataCache_->GetDataIndex("dataDescIndex1"); 336 337 stream_.traceDataCache_->GetDataTypeData()->AppendNewDataType(dataType, dataDescIndex); 338 stream_.traceDataCache_->GetDataTypeData()->AppendNewDataType(dataType1, dataDescIndex1); 339 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 340 EXPECT_EQ(row, 6); 341 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 342 EXPECT_EQ(row, 1); 343 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 344 EXPECT_EQ(row, 4); 345 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 346 EXPECT_EQ(row, 1); 347 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 348 EXPECT_EQ(row, 4); 349 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 350 EXPECT_EQ(row, 2); 351 } 352 /** 353 * @tc.name: DiskIoTableTest 354 * @tc.desc: Disk io table test 355 * @tc.type: FUNC 356 */ 357 HWTEST_F(TableTest, DiskIoTableTest, TestSize.Level1) 358 { 359 TS_LOGI("test31-10"); 360 std::string sqlSelect = "select * from diskio"; 361 uint64_t ts = 1663869124160; 362 uint64_t dur = 540; 363 uint64_t rd = 5; 364 uint64_t wr = 5; 365 uint64_t rdPerSec = 6; 366 uint64_t wrPerSec = 6; 367 double rdCountPerSec = 2; 368 double wrCountPerSec = 2; 369 uint64_t rdCount = 2; 370 uint64_t wrCount = 2; 371 372 stream_.traceDataCache_->GetDiskIOData()->AppendNewData(ts, dur, rd, wr, rdPerSec, wrPerSec, rdCountPerSec, 373 wrCountPerSec, rdCount, wrCount); 374 stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 375 } 376 /** 377 * @tc.name: EbpfCallstackTableTest 378 * @tc.desc: Ebpf callstack table test 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(TableTest, EbpfCallstackTableTest, TestSize.Level1) 382 { 383 TS_LOGI("test31-11"); 384 std::string sqlSelect = "select * from ebpf_callstack"; 385 std::string sqlSelect1 = "select * from ebpf_callstack where id = 1"; 386 std::string sqlSelect2 = "select * from ebpf_callstack where id > 1"; 387 std::string sqlSelect3 = "select * from ebpf_callstack where id < 1"; 388 std::string sqlSelect4 = "select * from ebpf_callstack where id >= 1"; 389 std::string sqlSelect5 = "select * from ebpf_callstack where id <= 1"; 390 std::string sqlSelect6 = "select * from hidump"; 391 uint64_t callChainId = 1; 392 uint32_t depth = 1; 393 uint64_t ip = 1; 394 uint64_t symbolId = 1; 395 uint64_t filePathId = 1; 396 397 uint64_t callChainId1 = 2; 398 uint32_t depth1 = 2; 399 uint64_t ip1 = 2; 400 uint64_t symbolId1 = 2; 401 uint64_t filePathId1 = 2; 402 403 uint64_t timeStamp = 1663869124160; 404 uint32_t fps = 1; 405 406 uint64_t timestamp1 = 1663869224160; 407 uint32_t fps1 = 2; 408 409 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timeStamp, fps); 410 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timestamp1, fps1); 411 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect6.c_str(), false); 412 EXPECT_EQ(row, 2); 413 414 stream_.traceDataCache_->GetEbpfCallStack()->AppendNewData(callChainId, depth, ip, symbolId, filePathId); 415 stream_.traceDataCache_->GetEbpfCallStack()->AppendNewData(callChainId1, depth1, ip1, symbolId1, filePathId1); 416 row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 417 EXPECT_EQ(row, 2); 418 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 419 EXPECT_EQ(row, 1); 420 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 421 EXPECT_EQ(row, 0); 422 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 423 EXPECT_EQ(row, 1); 424 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 425 EXPECT_EQ(row, 1); 426 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 427 EXPECT_EQ(row, 2); 428 } 429 /** 430 * @tc.name: FileSystemSampleTableTest 431 * @tc.desc: File system sample table test 432 * @tc.type: FUNC 433 */ 434 HWTEST_F(TableTest, FileSystemSampleTableTest, TestSize.Level1) 435 { 436 TS_LOGI("test31-12"); 437 std::string sqlSelect = "select * from file_system_sample"; 438 std::string sqlSelect1 = "select * from file_system_sample where id = 1"; 439 std::string sqlSelect2 = "select * from file_system_sample where type > 1"; 440 std::string sqlSelect3 = "select * from hidump"; 441 std::string sqlSelect4 = "select * from hidump where id = 1"; 442 std::string sqlSelect5 = "select * from hidump where ts < 1663869124160"; 443 // std::string sqlSelect6 = "select * from hidump"; 444 uint64_t callChainId = 1; 445 uint16_t type = 1; 446 uint32_t ipid = 1; 447 uint32_t itid = 1; 448 uint64_t startTs = 1663869124160; 449 uint64_t endTs = 1663869124260; 450 uint64_t dur = 100; 451 DataIndex returnValue = stream_.traceDataCache_->GetDataIndex("returnValue"); 452 DataIndex errorCode = stream_.traceDataCache_->GetDataIndex("errorCode"); 453 size_t size = 1; 454 int32_t fd = 0; 455 DataIndex fileId = stream_.traceDataCache_->GetDataIndex("fileId"); 456 DataIndex firstArgument = stream_.traceDataCache_->GetDataIndex("firstArgument"); 457 DataIndex secondArgument = stream_.traceDataCache_->GetDataIndex("secondArgument"); 458 DataIndex thirdArgument = stream_.traceDataCache_->GetDataIndex("thirdArgument"); 459 DataIndex fourthArgument = stream_.traceDataCache_->GetDataIndex("fourthArgument"); 460 461 uint64_t callChainId1 = 2; 462 uint16_t type1 = 2; 463 uint32_t ipid1 = 2; 464 uint32_t itid1 = 2; 465 uint64_t startTs1 = 1663869124161; 466 uint64_t endTs1 = 1663869124261; 467 uint64_t dur1 = 200; 468 DataIndex returnValue1 = stream_.traceDataCache_->GetDataIndex("returnValue1"); 469 DataIndex errorCode1 = stream_.traceDataCache_->GetDataIndex("errorCode1"); 470 size_t size1 = 2; 471 int32_t fd1 = 1; 472 DataIndex fileId1 = stream_.traceDataCache_->GetDataIndex("fileId1"); 473 DataIndex firstArgument1 = stream_.traceDataCache_->GetDataIndex("firstArgument1"); 474 DataIndex secondArgument1 = stream_.traceDataCache_->GetDataIndex("secondArgument1"); 475 DataIndex thirdArgument1 = stream_.traceDataCache_->GetDataIndex("thirdArgument1"); 476 DataIndex fourthArgument1 = stream_.traceDataCache_->GetDataIndex("fourthArgument1"); 477 478 uint64_t timeStamp = 1663869124160; 479 uint32_t fps = 1; 480 481 uint64_t timestamp1 = 1663869224160; 482 uint32_t fps1 = 2; 483 484 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timeStamp, fps); 485 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timestamp1, fps1); 486 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 487 EXPECT_EQ(row, 2); 488 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 489 EXPECT_EQ(row, 1); 490 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 491 EXPECT_EQ(row, 0); 492 493 stream_.traceDataCache_->GetFileSystemSample()->AppendNewData( 494 callChainId, type, ipid, itid, startTs, endTs, dur, returnValue, errorCode, size, fd, fileId, firstArgument, 495 secondArgument, thirdArgument, fourthArgument); 496 stream_.traceDataCache_->GetFileSystemSample()->AppendNewData( 497 callChainId1, type1, ipid1, itid1, startTs1, endTs1, dur1, returnValue1, errorCode1, size1, fd1, fileId1, 498 firstArgument1, secondArgument1, thirdArgument1, fourthArgument1); 499 row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 500 EXPECT_EQ(row, 2); 501 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 502 EXPECT_EQ(row, 1); 503 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 504 EXPECT_EQ(row, 1); 505 } 506 /** 507 * @tc.name: HidumpTableTest 508 * @tc.desc: Hidump table test 509 * @tc.type: FUNC 510 */ 511 HWTEST_F(TableTest, HidumpTableTest, TestSize.Level1) 512 { 513 TS_LOGI("test31-13"); 514 std::string sqlSelect = "select * from hidump"; 515 uint64_t timeStamp = 1663869124160; 516 uint32_t fps = 1; 517 518 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timeStamp, fps); 519 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 520 EXPECT_EQ(row, 1); 521 } 522 /** 523 * @tc.name: HisysEventMeasureTableTest 524 * @tc.desc: Hisys event measure table test 525 * @tc.type: FUNC 526 */ 527 HWTEST_F(TableTest, HisysEventMeasureTableTest, TestSize.Level1) 528 { 529 TS_LOGI("test31-14"); 530 std::string sqlSelect = "select * from hisys_event_measure"; 531 uint64_t serial = 1; 532 uint64_t ts = 1663869124160; 533 uint32_t nameId = stream_.traceDataCache_->GetDataIndex("event"); 534 uint32_t keyId = stream_.traceDataCache_->GetDataIndex("data"); 535 int32_t type = 1; 536 double numericValue = 0; 537 DataIndex stringValue = stream_.traceDataCache_->GetDataIndex("stringValue"); 538 539 stream_.traceDataCache_->GetSyseventMeasureData()->AppendData(ts, nameId, keyId, type, numericValue, stringValue, 540 serial); 541 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 542 EXPECT_EQ(row, 1); 543 } 544 /** 545 * @tc.name: InstantTableTest 546 * @tc.desc: Instant table test 547 * @tc.type: FUNC 548 */ 549 HWTEST_F(TableTest, InstantTableTest, TestSize.Level1) 550 { 551 TS_LOGI("test31-15"); 552 std::string sqlSelect = "select * from instant"; 553 std::string sqlSelect2 = "select * from instant where name = \"name\""; 554 std::string sqlSelect3 = "select * from instant where ts < 1663869124160"; 555 std::string sqlSelect4 = "select * from instant where ref > 1"; 556 std::string sqlSelect5 = "select * from instant where wakeup_from >= 1"; 557 uint64_t timeStamp = 1663869124160; 558 DataIndex nameIndex = stream_.traceDataCache_->GetDataIndex("name"); 559 int64_t internalTid = 1; 560 int64_t wakeupFromInternalPid = 1; 561 562 DataIndex nameIndex1 = stream_.traceDataCache_->GetDataIndex("name1"); 563 int64_t internalTid1 = 2; 564 int64_t wakeupFromInternalPid1 = 2; 565 566 std::string sqlSelect1 = "select * from measure"; 567 uint32_t type = 1; 568 int64_t value = 1; 569 uint32_t filterId = 1; 570 571 uint32_t type1 = 2; 572 uint64_t timestamp1 = 1663869124160; 573 int64_t value1 = 2; 574 uint32_t filterId1 = 2; 575 576 stream_.traceDataCache_->GetMeasureData()->AppendMeasureData(type, timeStamp, value, filterId); 577 stream_.traceDataCache_->GetMeasureData()->AppendMeasureData(type1, timestamp1, value1, filterId1); 578 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 579 EXPECT_EQ(row, 2); 580 581 stream_.traceDataCache_->GetInstantsData()->AppendInstantEventData(timeStamp, nameIndex, internalTid, 582 wakeupFromInternalPid); 583 stream_.traceDataCache_->GetInstantsData()->AppendInstantEventData(timestamp1, nameIndex1, internalTid1, 584 wakeupFromInternalPid1); 585 row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 586 EXPECT_EQ(row, 2); 587 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 588 EXPECT_EQ(row, 2); 589 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 590 EXPECT_EQ(row, 2); 591 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 592 EXPECT_EQ(row, 1); 593 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 594 EXPECT_EQ(row, 0); 595 } 596 /** 597 * @tc.name: IoLatencySampleTableTest 598 * @tc.desc: Io latency sample table test 599 * @tc.type: FUNC 600 */ 601 HWTEST_F(TableTest, IoLatencySampleTableTest, TestSize.Level1) 602 { 603 TS_LOGI("test31-16"); 604 std::string sqlSelect = "select * from bio_latency_sample"; 605 std::string sqlSelect1 = "select * from hidump"; 606 std::string sqlSelect2 = "select * from bio_latency_sample where id = 1"; 607 uint64_t callChainId = 1; 608 uint64_t type = 1; 609 uint64_t ipid = 1; 610 uint64_t itid = 1; 611 uint64_t startTs = 1663869124160; 612 uint64_t endTs = 1663869224160; 613 uint64_t latencyDur = 200; 614 uint32_t tier = 1; 615 uint64_t size = 1; 616 uint64_t blockNumber = 1; 617 uint64_t filePathId = stream_.traceDataCache_->GetDataIndex("filePathId"); 618 uint64_t durPer4k = 1; 619 620 uint64_t callChainId1 = 2; 621 uint64_t type1 = 2; 622 uint64_t ipid1 = 2; 623 uint64_t itid1 = 2; 624 uint64_t startTs1 = 1663869224160; 625 uint64_t endTs1 = 1663869424160; 626 uint64_t latencyDur1 = 200; 627 uint32_t tier1 = 2; 628 uint64_t size1 = 2; 629 uint64_t blockNumber1 = 2; 630 uint64_t filePathId1 = stream_.traceDataCache_->GetDataIndex("filePathId1"); 631 uint64_t durPer4k1 = 2; 632 633 uint64_t timeStamp = 1663869124160; 634 uint32_t fps = 1; 635 636 uint64_t timestamp1 = 1663869224160; 637 uint32_t fps1 = 2; 638 639 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timeStamp, fps); 640 stream_.traceDataCache_->GetHidumpData()->AppendNewHidumpInfo(timestamp1, fps1); 641 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 642 EXPECT_EQ(row, 2); 643 644 stream_.traceDataCache_->GetBioLatencySampleData()->AppendNewData( 645 callChainId, type, ipid, itid, startTs, endTs, latencyDur, tier, size, blockNumber, filePathId, durPer4k); 646 stream_.traceDataCache_->GetBioLatencySampleData()->AppendNewData(callChainId1, type1, ipid1, itid1, startTs1, 647 endTs1, latencyDur1, tier1, size1, blockNumber1, 648 filePathId1, durPer4k1); 649 row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 650 EXPECT_EQ(row, 2); 651 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 652 EXPECT_EQ(row, 1); 653 } 654 /** 655 * @tc.name: IrqTableTest 656 * @tc.desc: Irq table test 657 * @tc.type: FUNC 658 */ 659 HWTEST_F(TableTest, IrqTableTest, TestSize.Level1) 660 { 661 TS_LOGI("test31-17"); 662 std::string sqlSelect = "select * from irq"; 663 std::string sqlSelect1 = "select * from irq where id < 2"; 664 uint64_t startT = 1663869124160; 665 uint64_t durationNs = 200; 666 InternalTid internalTid = 1; 667 DataIndex cat = stream_.traceDataCache_->GetDataIndex("cat"); 668 uint16_t nameIdentify = 1; 669 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 670 uint8_t depth = 1; 671 const std::optional<uint64_t>& parentId = 1; 672 673 uint64_t startT1 = 1663869224160; 674 uint64_t durationNs1 = 200; 675 InternalTid internalTid1 = 2; 676 DataIndex cat1 = stream_.traceDataCache_->GetDataIndex("cat1"); 677 uint16_t nameIdentify1 = 2; 678 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 679 uint8_t depth1 = 2; 680 const std::optional<uint64_t>& parentId1 = 2; 681 682 stream_.traceDataCache_->GetIrqData()->AppendInternalSlice(startT, durationNs, internalTid, cat, nameIdentify, name, 683 depth, parentId); 684 stream_.traceDataCache_->GetIrqData()->AppendInternalSlice(startT1, durationNs1, internalTid1, cat1, nameIdentify1, 685 name1, depth1, parentId1); 686 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 687 EXPECT_EQ(row, 2); 688 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 689 EXPECT_EQ(row, 2); 690 } 691 /** 692 * @tc.name: LiveProcessTableTest 693 * @tc.desc: Live Process table test 694 * @tc.type: FUNC 695 */ 696 HWTEST_F(TableTest, LiveProcessTableTest, TestSize.Level1) 697 { 698 TS_LOGI("test31-18"); 699 std::string sqlSelect = "select * from live_process"; 700 uint64_t newTimeStamp = 1663869124160; 701 uint64_t dur = 200; 702 int32_t processID = 1; 703 std::string processName = "processName"; 704 int32_t parentProcessID = 1; 705 int32_t uid = 1; 706 std::string userName = "userName"; 707 double cpuUsage = 1; 708 int32_t pssInfo = 1; 709 uint64_t cpuTime = 1663888624160; 710 int32_t threads = 1; 711 int64_t diskWrites = 1; 712 int64_t diskReads = 1; 713 714 stream_.traceDataCache_->GetLiveProcessData()->AppendNewData(newTimeStamp, dur, processID, processName, 715 parentProcessID, uid, userName, cpuUsage, pssInfo, 716 cpuTime, threads, diskWrites, diskReads); 717 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 718 EXPECT_EQ(row, 1); 719 } 720 /** 721 * @tc.name: LogTableTest 722 * @tc.desc: Log table test 723 * @tc.type: FUNC 724 */ 725 HWTEST_F(TableTest, LogTableTest, TestSize.Level1) 726 { 727 TS_LOGI("test31-19"); 728 std::string sqlSelect = "select * from log"; 729 uint64_t seq = 1; 730 uint64_t timeStamp = 1663869124160; 731 uint32_t pid = 1; 732 uint32_t tid = 1; 733 DataIndex level = stream_.traceDataCache_->GetDataIndex("leve"); 734 DataIndex tag = stream_.traceDataCache_->GetDataIndex("tag"); 735 DataIndex context = stream_.traceDataCache_->GetDataIndex("context"); 736 uint64_t originTs = 1; 737 738 stream_.traceDataCache_->GetHilogData()->AppendNewLogInfo(seq, timeStamp, pid, tid, level, tag, context, originTs); 739 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 740 EXPECT_EQ(row, 1); 741 } 742 /** 743 * @tc.name: MeasureTableTest 744 * @tc.desc: Measure table test 745 * @tc.type: FUNC 746 */ 747 HWTEST_F(TableTest, MeasureTableTest, TestSize.Level1) 748 { 749 TS_LOGI("test31-20"); 750 std::string sqlSelect = "select * from measure"; 751 std::string sqlSelect1 = "select * from measure where ts = 1663869124160"; 752 uint32_t type = 1; 753 uint64_t timeStamp = 1663869124160; 754 int64_t value = 1; 755 uint32_t filterId = 1; 756 757 uint32_t type1 = 2; 758 uint64_t timestamp1 = 1663869224160; 759 int64_t value1 = 2; 760 uint32_t filterId1 = 2; 761 762 stream_.traceDataCache_->GetMeasureData()->AppendMeasureData(type, timeStamp, value, filterId); 763 stream_.traceDataCache_->GetMeasureData()->AppendMeasureData(type1, timestamp1, value1, filterId1); 764 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 765 EXPECT_EQ(row, 2); 766 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 767 EXPECT_EQ(row, 1); 768 } 769 /** 770 * @tc.name: MeasureFilterTableTest 771 * @tc.desc: Measure Filter table test 772 * @tc.type: FUNC 773 */ 774 HWTEST_F(TableTest, MeasureFilterTableTest, TestSize.Level1) 775 { 776 TS_LOGI("test31-21"); 777 std::string sqlSelect = "select * from measure_filter"; 778 uint64_t filterId = stream_.traceDataCache_->GetDataIndex("filter"); 779 ; 780 uint32_t nameIndex = stream_.traceDataCache_->GetDataIndex("name"); 781 uint64_t internalTid = 1; 782 783 stream_.traceDataCache_->GetThreadMeasureFilterData()->AppendNewFilter(filterId, nameIndex, internalTid); 784 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 785 EXPECT_EQ(row, 0); 786 } 787 /** 788 * @tc.name: MetaTableTest 789 * @tc.desc: Meta table test 790 * @tc.type: FUNC 791 */ 792 HWTEST_F(TableTest, MetaTableTest, TestSize.Level1) 793 { 794 TS_LOGI("test31-22"); 795 std::string sqlSelect = "select * from meta"; 796 797 stream_.traceDataCache_->GetMetaData(); 798 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 799 EXPECT_EQ(row, 9); 800 } 801 /** 802 * @tc.name: NativeHookTableTest 803 * @tc.desc: Native hook table test 804 * @tc.type: FUNC 805 */ 806 HWTEST_F(TableTest, NativeHookTableTest, TestSize.Level1) 807 { 808 TS_LOGI("test31-23"); 809 std::string sqlSelect = "select * from native_hook"; 810 std::string sqlSelect1 = "select * from native_hook where id = 1"; 811 std::string sqlSelect2 = "select * from native_hook where ipid > 1"; 812 std::string sqlSelect3 = "select * from native_hook where itid >= 1"; 813 std::string sqlSelect4 = "select * from native_hook where callchain_id < 1"; 814 uint64_t callChainId = 1; 815 uint32_t ipid = 1; 816 uint32_t itid = 1; 817 std::string eventType = "eventType"; 818 DataIndex subType = stream_.traceDataCache_->GetDataIndex("subType"); 819 uint64_t timeStamp = 1663869124160; 820 uint64_t endTimestamp = 1663869124360; 821 uint64_t duration = 200; 822 uint64_t addr = 1; 823 int64_t memSize = 1; 824 int64_t curMemSize = 1; 825 826 uint64_t callChainId1 = 2; 827 uint32_t ipid1 = 2; 828 uint32_t itid1 = 2; 829 std::string eventType1 = "eventType1"; 830 DataIndex subType1 = stream_.traceDataCache_->GetDataIndex("subType1"); 831 uint64_t timestamp1 = 1663869224160; 832 uint64_t endTimestamp1 = 1663869224360; 833 uint64_t duration1 = 200; 834 uint64_t addr1 = 2; 835 int64_t memSize1 = 2; 836 int64_t curMemSize1 = 2; 837 838 stream_.traceDataCache_->GetNativeHookData()->AppendNewNativeHookData( 839 callChainId, ipid, itid, eventType, subType, timeStamp, endTimestamp, duration, addr, memSize); 840 stream_.traceDataCache_->GetNativeHookData()->AppendNewNativeHookData( 841 callChainId1, ipid1, itid1, eventType1, subType1, timestamp1, endTimestamp1, duration1, addr1, memSize1); 842 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 843 EXPECT_EQ(row, 2); 844 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 845 EXPECT_EQ(row, 1); 846 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 847 EXPECT_EQ(row, 1); 848 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 849 EXPECT_EQ(row, 0); 850 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 851 EXPECT_EQ(row, 0); 852 } 853 /** 854 * @tc.name: NativeHookFrameTableTest 855 * @tc.desc: Native hook Frame table test 856 * @tc.type: FUNC 857 */ 858 HWTEST_F(TableTest, NativeHookFrameTableTest, TestSize.Level1) 859 { 860 TS_LOGI("test31-24"); 861 std::string sqlSelect = "select * from native_hook_frame"; 862 std::string sqlSelect1 = "select * from native_hook_frame where id = 1"; 863 std::string sqlSelect2 = "select * from native_hook_frame where callchain_id > 1"; 864 std::string sqlSelect3 = "select * from native_hook_frame where symbol_id >= 1"; 865 std::string sqlSelect4 = "select * from native_hook_frame where file_id < 2"; 866 uint64_t callChainId = 1; 867 uint64_t depth = 1; 868 uint64_t ip = 1; 869 uint64_t sp = 1; 870 DataIndex symbolName = stream_.traceDataCache_->GetDataIndex("symbolName"); 871 DataIndex filePath = stream_.traceDataCache_->GetDataIndex("filePath"); 872 uint64_t offset = 1; 873 uint64_t symbolOffset = 1; 874 const std::string vaddr = "addr"; 875 876 uint64_t callChainId1 = 2; 877 uint64_t depth1 = 2; 878 uint64_t ip1 = 2; 879 uint64_t sp1 = 2; 880 DataIndex symbolName1 = stream_.traceDataCache_->GetDataIndex("symbolName1"); 881 DataIndex filePath1 = stream_.traceDataCache_->GetDataIndex("filePath1"); 882 uint64_t offset1 = 2; 883 uint64_t symbolOffset1 = 2; 884 const std::string vaddr1 = "addr1"; 885 886 stream_.traceDataCache_->GetNativeHookFrameData()->AppendNewNativeHookFrame(callChainId, depth, ip, sp, symbolName, 887 filePath, offset, symbolOffset, vaddr); 888 stream_.traceDataCache_->GetNativeHookFrameData()->AppendNewNativeHookFrame( 889 callChainId1, depth1, ip1, sp1, symbolName1, filePath1, offset1, symbolOffset1, vaddr1); 890 891 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 892 EXPECT_EQ(row, 2); 893 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 894 EXPECT_EQ(row, 1); 895 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 896 EXPECT_EQ(row, 1); 897 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 898 EXPECT_EQ(row, 0); 899 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 900 EXPECT_EQ(row, 0); 901 } 902 /** 903 * @tc.name: NetworkTableTest 904 * @tc.desc: Network table test 905 * @tc.type: FUNC 906 */ 907 HWTEST_F(TableTest, NetworkTableTest, TestSize.Level1) 908 { 909 TS_LOGI("test31-25"); 910 std::string sqlSelect = "select * from network"; 911 uint64_t newTimeStamp = 1663869124160; 912 uint64_t tx = 1; 913 uint64_t rx = 1; 914 uint64_t dur = 200; 915 double rxSpeed = 1; 916 double txSpeed = 1; 917 uint64_t packetIn = 1; 918 double packetInSec = 1; 919 uint64_t packetOut = 1; 920 double packetOutSec = 1; 921 const std::string& netType = "nettype"; 922 923 stream_.traceDataCache_->GetNetworkData()->AppendNewNetData(newTimeStamp, tx, rx, dur, rxSpeed, txSpeed, packetIn, 924 packetInSec, packetOut, packetOutSec, netType); 925 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 926 EXPECT_EQ(row, 1); 927 } 928 /** 929 * @tc.name: PerfCallchainTableTest 930 * @tc.desc: Perf callchain table test 931 * @tc.type: FUNC 932 */ 933 HWTEST_F(TableTest, PerfCallchainTableTest, TestSize.Level1) 934 { 935 TS_LOGI("test31-26"); 936 std::string sqlSelect = "select * from perf_callchain"; 937 std::string sqlSelect1 = "select * from perf_callchain where id = 1"; 938 std::string sqlSelect2 = "select * from perf_callchain where callchain_id > 1"; 939 std::string sqlSelect3 = "select * from perf_callchain where file_id < 1"; 940 std::string sqlSelect4 = "select * from perf_callchain where symbol_id >= 1"; 941 uint64_t sampleId = stream_.traceDataCache_->GetDataIndex("sample"); 942 uint64_t callChainId = stream_.traceDataCache_->GetDataIndex("callChain"); 943 uint64_t vaddrInFile = 1; 944 uint64_t fileId = stream_.traceDataCache_->GetDataIndex("file"); 945 uint64_t symbolId = stream_.traceDataCache_->GetDataIndex("symbolId"); 946 947 uint64_t sampleId1 = stream_.traceDataCache_->GetDataIndex("sample1"); 948 uint64_t callChainId1 = stream_.traceDataCache_->GetDataIndex("callChain1"); 949 uint64_t vaddrInFile1 = 2; 950 uint64_t fileId1 = stream_.traceDataCache_->GetDataIndex("file1"); 951 uint64_t symbolId1 = stream_.traceDataCache_->GetDataIndex("symbolId1"); 952 953 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(sampleId, callChainId, vaddrInFile, fileId, 954 symbolId); 955 956 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(sampleId1, callChainId1, vaddrInFile1, 957 fileId1, symbolId1); 958 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 959 EXPECT_EQ(row, 2); 960 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 961 EXPECT_EQ(row, 1); 962 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 963 EXPECT_EQ(row, 2); 964 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 965 EXPECT_EQ(row, 0); 966 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 967 EXPECT_EQ(row, 0); 968 } 969 /** 970 * @tc.name: PerfFilesTableTest 971 * @tc.desc: Perf files table test 972 * @tc.type: FUNC 973 */ 974 HWTEST_F(TableTest, PerfFilesTableTest, TestSize.Level1) 975 { 976 TS_LOGI("test31-27"); 977 std::string sqlSelect = "select * from perf_files"; 978 std::string sqlSelect1 = "select * from perf_files where id = 1"; 979 std::string sqlSelect2 = "select * from perf_files where file_id < 1"; 980 uint64_t fileIds = stream_.traceDataCache_->GetDataIndex("file"); 981 uint32_t serial = 1; 982 DataIndex symbols = stream_.traceDataCache_->GetDataIndex("symbol"); 983 DataIndex filePath = stream_.traceDataCache_->GetDataIndex("filePath"); 984 985 uint64_t fileIds1 = stream_.traceDataCache_->GetDataIndex("file1"); 986 uint32_t serial1 = 1; 987 DataIndex symbols1 = stream_.traceDataCache_->GetDataIndex("symbol1"); 988 DataIndex filePath1 = stream_.traceDataCache_->GetDataIndex("filePath1"); 989 990 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds, serial, symbols, filePath); 991 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds1, serial1, symbols1, filePath1); 992 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 993 EXPECT_EQ(row, 2); 994 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 995 EXPECT_EQ(row, 1); 996 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 997 EXPECT_EQ(row, 0); 998 } 999 /** 1000 * @tc.name: PerfReportTableTest 1001 * @tc.desc: Perf report table test 1002 * @tc.type: FUNC 1003 */ 1004 HWTEST_F(TableTest, PerfReportTableTest, TestSize.Level1) 1005 { 1006 TS_LOGI("test31-28"); 1007 std::string sqlSelect = "select * from perf_report"; 1008 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1009 DataIndex value = stream_.traceDataCache_->GetDataIndex("value"); 1010 1011 stream_.traceDataCache_->GetPerfReportData()->AppendNewPerfReport(type, value); 1012 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1013 EXPECT_EQ(row, 1); 1014 } 1015 /** 1016 * @tc.name: PerfSampleTableTest 1017 * @tc.desc: Perf sample table test 1018 * @tc.type: FUNC 1019 */ 1020 HWTEST_F(TableTest, PerfSampleTableTest, TestSize.Level1) 1021 { 1022 TS_LOGI("test31-29"); 1023 std::string sqlSelect = "select * from perf_sample"; 1024 std::string sqlSelect1 = "select * from perf_sample where id = 1"; 1025 std::string sqlSelect2 = "select * from perf_sample where callchain_id > 1"; 1026 std::string sqlSelect3 = "select * from perf_sample where thread_id < 1"; 1027 std::string sqlSelect4 = "select * from perf_sample where event_type_id >= 1"; 1028 std::string sqlSelect5 = "select * from perf_sample where cpu_id <= 1"; 1029 uint64_t sampleId = stream_.traceDataCache_->GetDataIndex("type"); 1030 uint64_t timeStamp = 1663869124160; 1031 uint64_t tid = 1; 1032 uint64_t eventCount = 2; 1033 uint64_t eventTypeId = 1; 1034 uint64_t timestampTrace = 1; 1035 uint64_t cpuId = 1; 1036 uint64_t threadState = stream_.traceDataCache_->GetDataIndex("threadState"); 1037 1038 uint64_t sampleId1 = stream_.traceDataCache_->GetDataIndex("type1"); 1039 uint64_t timestamp1 = 1663869124160; 1040 uint64_t tid1 = 2; 1041 uint64_t eventCount1 = 3; 1042 uint64_t eventTypeId1 = 2; 1043 uint64_t timestampTrace1 = 2; 1044 uint64_t cpuId1 = 2; 1045 uint64_t threadState1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 1046 1047 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample(sampleId, timeStamp, tid, eventCount, eventTypeId, 1048 timestampTrace, cpuId, threadState); 1049 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample( 1050 sampleId1, timestamp1, tid1, eventCount1, eventTypeId1, timestampTrace1, cpuId1, threadState1); 1051 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1052 EXPECT_EQ(row, 2); 1053 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1054 EXPECT_EQ(row, 1); 1055 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1056 EXPECT_EQ(row, 2); 1057 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1058 EXPECT_EQ(row, 0); 1059 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1060 EXPECT_EQ(row, 0); 1061 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1062 EXPECT_EQ(row, 1); 1063 } 1064 /** 1065 * @tc.name: PerfThreadTableTest 1066 * @tc.desc: Perf Thread table test 1067 * @tc.type: FUNC 1068 */ 1069 HWTEST_F(TableTest, PerfThreadTableTest, TestSize.Level1) 1070 { 1071 TS_LOGI("test31-30"); 1072 std::string sqlSelect = "select * from perf_thread"; 1073 std::string sqlSelect1 = "select * from perf_thread where id = 1"; 1074 std::string sqlSelect2 = "select * from perf_thread where thread_id > 1"; 1075 std::string sqlSelect3 = "select * from perf_thread where process_id < 1"; 1076 uint64_t pid = 1; 1077 uint64_t tid = 1; 1078 DataIndex threadName = stream_.traceDataCache_->GetDataIndex("threadState"); 1079 1080 uint64_t pid1 = 2; 1081 uint64_t tid1 = 2; 1082 DataIndex threadName1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 1083 1084 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid, tid, threadName); 1085 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid1, tid1, threadName1); 1086 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1087 EXPECT_EQ(row, 2); 1088 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1089 EXPECT_EQ(row, 1); 1090 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1091 EXPECT_EQ(row, 1); 1092 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1093 EXPECT_EQ(row, 0); 1094 } 1095 /** 1096 * @tc.name: ProcessTableTest 1097 * @tc.desc: Process table test 1098 * @tc.type: FUNC 1099 */ 1100 HWTEST_F(TableTest, ProcessTableTest, TestSize.Level1) 1101 { 1102 TS_LOGI("test31-31"); 1103 std::string sqlSelect = "select * from process"; 1104 std::string sqlSelect1 = "select * from process where id = 1"; 1105 1106 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1107 EXPECT_EQ(row, 1); 1108 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1109 EXPECT_EQ(row, 0); 1110 } 1111 /** 1112 * @tc.name: ProcessFilterTableTest 1113 * @tc.desc: Process filter table test 1114 * @tc.type: FUNC 1115 */ 1116 HWTEST_F(TableTest, ProcessFilterTableTest, TestSize.Level1) 1117 { 1118 TS_LOGI("test31-32"); 1119 std::string sqlSelect = "select * from process_filter"; 1120 uint64_t id = 1; 1121 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 1122 uint32_t internalPid = 1; 1123 1124 stream_.traceDataCache_->GetProcessFilterData()->AppendNewFilter(id, name, internalPid); 1125 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1126 EXPECT_EQ(row, 1); 1127 } 1128 /** 1129 * @tc.name: ProcessMeasureTableTest 1130 * @tc.desc: Process Measure table test 1131 * @tc.type: FUNC 1132 */ 1133 HWTEST_F(TableTest, ProcessMeasureTableTest, TestSize.Level1) 1134 { 1135 TS_LOGI("test31-33"); 1136 std::string sqlSelect = "select * from process_measure"; 1137 uint32_t type = 1; 1138 uint64_t timeStamp = 1663869124160; 1139 int64_t value = 1; 1140 uint32_t filterId = 1; 1141 1142 stream_.traceDataCache_->GetProcessMeasureData()->AppendMeasureData(type, timeStamp, value, filterId); 1143 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1144 EXPECT_EQ(row, 1); 1145 } 1146 /** 1147 * @tc.name: ProcessMeasureFilterTableTest 1148 * @tc.desc: Process Measure filter table test 1149 * @tc.type: FUNC 1150 */ 1151 HWTEST_F(TableTest, ProcessMeasureFilterTableTest, TestSize.Level1) 1152 { 1153 TS_LOGI("test31-34"); 1154 std::string sqlSelect = "select * from process_measure_filter"; 1155 std::string sqlSelect1 = "select * from process_measure_filter where id = 1"; 1156 std::string sqlSelect2 = "select * from process_measure_filter where ipid < 1"; 1157 std::string sqlSelect3 = "select * from process_measure_filter where name = \"name\""; 1158 uint64_t id = 1; 1159 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 1160 uint32_t internalPid = 1; 1161 1162 uint64_t id1 = 1; 1163 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 1164 uint32_t internalPid1 = 1; 1165 1166 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id, name, internalPid); 1167 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id1, name1, internalPid1); 1168 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1169 EXPECT_EQ(row, 2); 1170 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1171 EXPECT_EQ(row, 2); 1172 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1173 EXPECT_EQ(row, 0); 1174 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1175 EXPECT_EQ(row, 2); 1176 } 1177 /** 1178 * @tc.name: RawTableTest 1179 * @tc.desc: Raw table test 1180 * @tc.type: FUNC 1181 */ 1182 HWTEST_F(TableTest, RawTableTest, TestSize.Level1) 1183 { 1184 TS_LOGI("test31-35"); 1185 std::string sqlSelect = "select * from raw"; 1186 std::string sqlSelect1 = "select * from raw where id = 1"; 1187 std::string sqlSelect2 = "select * from raw where name = \"sched_waking\""; 1188 std::string sqlSelect3 = "select * from raw where ts = 1663869124160"; 1189 std::string sqlSelect4 = "select * from raw where itid < 2"; 1190 uint32_t id = 1; 1191 uint64_t timeStamp = 1663869124160; 1192 uint32_t name = stream_.traceDataCache_->GetDataIndex("cpu_idle"); 1193 uint32_t cpu = 1; 1194 uint32_t internalTid = 1; 1195 1196 uint32_t id1 = 2; 1197 uint64_t timestamp1 = 1663869224160; 1198 uint32_t name1 = stream_.traceDataCache_->GetDataIndex("sched_waking"); 1199 uint32_t cpu1 = 2; 1200 uint32_t internalTid1 = 2; 1201 1202 stream_.traceDataCache_->GetRawData()->AppendRawData(id, timeStamp, name, cpu, internalTid); 1203 stream_.traceDataCache_->GetRawData()->AppendRawData(id1, timestamp1, name1, cpu1, internalTid1); 1204 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1205 EXPECT_EQ(row, 2); 1206 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1207 EXPECT_EQ(row, 1); 1208 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1209 EXPECT_EQ(row, 0); 1210 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1211 EXPECT_EQ(row, 1); 1212 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1213 EXPECT_EQ(row, 0); 1214 } 1215 /** 1216 * @tc.name: SchedSliceTest 1217 * @tc.desc: Sched slice table test 1218 * @tc.type: FUNC 1219 */ 1220 HWTEST_F(TableTest, SchedSliceTest, TestSize.Level1) 1221 { 1222 TS_LOGI("test31-36"); 1223 std::string sqlSelect = "select * from sched_slice"; 1224 std::string sqlSelect1 = "select * from sched_slice where id = 1"; 1225 std::string sqlSelect2 = "select * from sched_slice where ts > 1"; 1226 std::string sqlSelect3 = "select * from sched_slice where cpu < 1"; 1227 std::string sqlSelect4 = "select * from sched_slice where itid >= 1"; 1228 std::string sqlSelect5 = "select * from sched_slice where ipid <= 1"; 1229 std::string sqlSelect6 = "select * from sched_slice where dur >= 200"; 1230 uint64_t ts = 1663869124160; 1231 uint64_t dur = 200; 1232 uint64_t cpu = 1; 1233 uint64_t internalTid = 1; 1234 uint64_t endState = 1; 1235 uint64_t priority = 1; 1236 1237 uint64_t ts1 = 1663869224160; 1238 uint64_t dur1 = 200; 1239 uint64_t cpu1 = 2; 1240 uint64_t internalTid1 = 2; 1241 uint64_t endState1 = 2; 1242 uint64_t priority1 = 2; 1243 1244 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(ts, dur, cpu, internalTid, endState, priority); 1245 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(ts1, dur1, cpu1, internalTid1, endState1, priority1); 1246 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1247 EXPECT_EQ(row, 2); 1248 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1249 EXPECT_EQ(row, 1); 1250 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1251 EXPECT_EQ(row, 2); 1252 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1253 EXPECT_EQ(row, 0); 1254 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1255 EXPECT_EQ(row, 0); 1256 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1257 EXPECT_EQ(row, 0); 1258 row = stream_.traceDataCache_->SearchDatabase(sqlSelect6.c_str(), false); 1259 EXPECT_EQ(row, 0); 1260 } 1261 /** 1262 * @tc.name: SmapsTest 1263 * @tc.desc: Smaps table test 1264 * @tc.type: FUNC 1265 */ 1266 HWTEST_F(TableTest, SmapsTest, TestSize.Level1) 1267 { 1268 TS_LOGI("test31-37"); 1269 std::string sqlSelect = "select * from smaps"; 1270 uint64_t timeStamp = 1663869124160; 1271 std::string startAddr = "startAddr"; 1272 std::string endAddr = "endAddr"; 1273 uint64_t dirty = 1; 1274 uint64_t swapper = 1; 1275 uint64_t rss = 1; 1276 uint64_t pss = 1; 1277 uint64_t size = 2; 1278 double reside = 1; 1279 uint32_t ipid = 1; 1280 uint64_t sharedClean = 1; 1281 uint64_t sharedDirty = 1; 1282 uint64_t privateClean = 1; 1283 uint64_t privateDirty = 1; 1284 uint64_t swap = 1; 1285 uint64_t swapPss = 1; 1286 uint64_t type = 1; 1287 1288 DataIndex protectionId = stream_.traceDataCache_->GetDataIndex("protection"); 1289 DataIndex pathId = stream_.traceDataCache_->GetDataIndex("path"); 1290 1291 stream_.traceDataCache_->GetSmapsData()->AppendNewData( 1292 timeStamp, ipid, startAddr, endAddr, dirty, swapper, rss, pss, size, reside, protectionId, pathId, sharedClean, 1293 sharedDirty, privateClean, privateDirty, swap, swapPss, type); 1294 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1295 EXPECT_EQ(row, 1); 1296 } 1297 /** 1298 * @tc.name: StatTableTest 1299 * @tc.desc: Stat table test 1300 * @tc.type: FUNC 1301 */ 1302 HWTEST_F(TableTest, StatTableTest, TestSize.Level1) 1303 { 1304 TS_LOGI("test31-38"); 1305 std::string sqlSelect = "select * from stat"; 1306 stream_.traceDataCache_->GetStatAndInfo(); 1307 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1308 EXPECT_EQ(row, 430); 1309 } 1310 /** 1311 * @tc.name: SymbolsTableTest 1312 * @tc.desc: Symbols table test 1313 * @tc.type: FUNC 1314 */ 1315 HWTEST_F(TableTest, SymbolsTableTest, TestSize.Level1) 1316 { 1317 TS_LOGI("test31-39"); 1318 std::string sqlSelect = "select * from symbols"; 1319 std::string sqlSelect1 = "select * from symbols where id = 1"; 1320 std::string sqlSelect2 = "select * from symbols where id < 1"; 1321 const DataIndex& name = stream_.traceDataCache_->GetDataIndex("name"); 1322 const uint64_t& addr = 1; 1323 1324 const DataIndex& name1 = stream_.traceDataCache_->GetDataIndex("name1"); 1325 const uint64_t& addr1 = 2; 1326 1327 stream_.traceDataCache_->GetSymbolsData()->InsertSymbol(name, addr); 1328 stream_.traceDataCache_->GetSymbolsData()->InsertSymbol(name1, addr1); 1329 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1330 EXPECT_EQ(row, 2); 1331 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1332 EXPECT_EQ(row, 1); 1333 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1334 EXPECT_EQ(row, 1); 1335 } 1336 /** 1337 * @tc.name: SyscallTableTest 1338 * @tc.desc: Syscall table test 1339 * @tc.type: FUNC 1340 */ 1341 HWTEST_F(TableTest, SyscallTableTest, TestSize.Level1) 1342 { 1343 TS_LOGI("test31-40"); 1344 std::string sqlSelect = "select * from syscall"; 1345 int64_t sysCallNum = 1; 1346 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1347 uint64_t ipid = 1; 1348 uint64_t timeStamp = 1663869124160; 1349 int64_t ret = 1; 1350 1351 stream_.traceDataCache_->GetSysCallData()->AppendSysCallData(sysCallNum, type, ipid, timeStamp, ret); 1352 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1353 EXPECT_EQ(row, 1); 1354 } 1355 /** 1356 * @tc.name: SysEventFilterTableTest 1357 * @tc.desc: SysEventFilter table test 1358 * @tc.type: FUNC 1359 */ 1360 HWTEST_F(TableTest, SysEventFilterTableTest, TestSize.Level1) 1361 { 1362 TS_LOGI("test31-41"); 1363 std::string sqlSelect = "select * from sys_event_filter"; 1364 std::string sqlSelect1 = "select * from sys_event_filter where id = 1"; 1365 std::string sqlSelect2 = "select * from sys_event_filter where id > 1"; 1366 std::string sqlSelect3 = "select * from sys_event_filter where id < 1"; 1367 std::string sqlSelect4 = "select * from sys_event_filter where id >= 1"; 1368 std::string sqlSelect5 = "select * from sys_event_filter where id <= 1"; 1369 uint64_t filterId = 1; 1370 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1371 DataIndex nameId = stream_.traceDataCache_->GetDataIndex("name"); 1372 1373 uint64_t filterId1 = 2; 1374 DataIndex type1 = stream_.traceDataCache_->GetDataIndex("type1"); 1375 DataIndex nameId1 = stream_.traceDataCache_->GetDataIndex("name1"); 1376 1377 stream_.traceDataCache_->GetSysMeasureFilterData()->AppendNewFilter(filterId, type, nameId); 1378 stream_.traceDataCache_->GetSysMeasureFilterData()->AppendNewFilter(filterId1, type1, nameId1); 1379 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1380 EXPECT_EQ(row, 2); 1381 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1382 EXPECT_EQ(row, 1); 1383 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1384 EXPECT_EQ(row, 1); 1385 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1386 EXPECT_EQ(row, 1); 1387 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1388 EXPECT_EQ(row, 2); 1389 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1390 EXPECT_EQ(row, 2); 1391 } 1392 /** 1393 * @tc.name: SysMemMeasureTableTest 1394 * @tc.desc: SysMemMeasure table test 1395 * @tc.type: FUNC 1396 */ 1397 HWTEST_F(TableTest, SysMemMeasureTableTest, TestSize.Level1) 1398 { 1399 TS_LOGI("test31-42"); 1400 std::string sqlSelect = "select * from sys_mem_measure"; 1401 uint32_t type = 1; 1402 uint64_t timeStamp = 1663869124160; 1403 int64_t value = 1; 1404 uint32_t filterId = stream_.traceDataCache_->GetDataIndex("filter"); 1405 1406 stream_.traceDataCache_->GetSysMemMeasureData()->AppendMeasureData(type, timeStamp, value, filterId); 1407 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1408 EXPECT_EQ(row, 1); 1409 } 1410 /** 1411 * @tc.name: ThreadTableTest 1412 * @tc.desc: Thread table test 1413 * @tc.type: FUNC 1414 */ 1415 HWTEST_F(TableTest, ThreadTableTest, TestSize.Level1) 1416 { 1417 TS_LOGI("test31-43"); 1418 std::string sqlSelect = "select * from thread"; 1419 1420 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1421 EXPECT_EQ(row, 1); 1422 } 1423 /** 1424 * @tc.name: ThreadFilterTableTest 1425 * @tc.desc: ThreadFilter table test 1426 * @tc.type: FUNC 1427 */ 1428 HWTEST_F(TableTest, ThreadFilterTableTest, TestSize.Level1) 1429 { 1430 TS_LOGI("test31-44"); 1431 std::string sqlSelect = "select * from thread_filter"; 1432 uint64_t filterId = stream_.traceDataCache_->GetDataIndex("ilter"); 1433 uint32_t nameIndex = stream_.traceDataCache_->GetDataIndex("name"); 1434 uint64_t internalTid = 1; 1435 1436 stream_.traceDataCache_->GetThreadFilterData()->AppendNewFilter(filterId, nameIndex, internalTid); 1437 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1438 EXPECT_EQ(row, 1); 1439 } 1440 /** 1441 * @tc.name: ThreadStateTableTest 1442 * @tc.desc: ThreadState table test 1443 * @tc.type: FUNC 1444 */ 1445 HWTEST_F(TableTest, ThreadStateTableTest, TestSize.Level1) 1446 { 1447 TS_LOGI("test31-45"); 1448 std::string sqlSelect = "select * from thread_state"; 1449 std::string sqlSelect1 = "select * from thread_state where id = 1"; 1450 std::string sqlSelect2 = "select * from thread_state where tid > 1"; 1451 std::string sqlSelect3 = "select * from thread_state where pid < 1"; 1452 std::string sqlSelect4 = "select * from thread_state where itid >= 1"; 1453 std::string sqlSelect5 = "select * from thread_state where cpu <= 1"; 1454 std::string sqlSelect6 = "select * from thread_state where ts = 1663869124160"; 1455 std::string sqlSelect7 = "select * from thread_state where dur = 1"; 1456 std::string sqlSelect8 = "select * from thread_state where state = \"idState\""; 1457 InternalTime ts = 1663869124160; 1458 InternalTime dur = 200; 1459 InternalCpu cpu = 1; 1460 InternalTid itid = 1; 1461 TableRowId idState = 1; 1462 1463 InternalTime ts1 = 1663869224160; 1464 InternalTime dur1 = 200; 1465 InternalCpu cpu1 = 2; 1466 InternalTid itid1 = 2; 1467 TableRowId idState1 = 2; 1468 1469 stream_.traceDataCache_->GetThreadStateData()->AppendThreadState(ts, dur, cpu, itid, idState); 1470 stream_.traceDataCache_->GetThreadStateData()->AppendThreadState(ts1, dur1, cpu1, itid1, idState1); 1471 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1472 EXPECT_EQ(row, 2); 1473 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1474 EXPECT_EQ(row, 1); 1475 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1476 EXPECT_EQ(row, 2); 1477 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1478 EXPECT_EQ(row, 0); 1479 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1480 EXPECT_EQ(row, 0); 1481 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1482 EXPECT_EQ(row, 1); 1483 row = stream_.traceDataCache_->SearchDatabase(sqlSelect6.c_str(), false); 1484 EXPECT_EQ(row, 1); 1485 row = stream_.traceDataCache_->SearchDatabase(sqlSelect7.c_str(), false); 1486 EXPECT_EQ(row, 0); 1487 row = stream_.traceDataCache_->SearchDatabase(sqlSelect8.c_str(), false); 1488 EXPECT_EQ(row, 0); 1489 } 1490 /** 1491 * @tc.name: TraceRangeTableTest 1492 * @tc.desc: TraceRange table test 1493 * @tc.type: FUNC 1494 */ 1495 HWTEST_F(TableTest, TraceRangeTableTest, TestSize.Level1) 1496 { 1497 TS_LOGI("test31-46"); 1498 std::string sqlSelect = "select * from trace_range"; 1499 1500 stream_.traceDataCache_->UpdateTraceRange(); 1501 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1502 EXPECT_EQ(row, 1); 1503 } 1504 } // namespace TraceStreamer 1505 } // namespace SysTuning 1506