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, 52); 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, 50); 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, 51); 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, 540 nameId, keyId, type, numericValue, stringValue, 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 uint32_t nameIndex = stream_.traceDataCache_->GetDataIndex("name"); 780 uint64_t internalTid = 1; 781 782 stream_.traceDataCache_->GetThreadMeasureFilterData()->AppendNewFilter(filterId, nameIndex, internalTid); 783 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 784 EXPECT_EQ(row, 0); 785 } 786 /** 787 * @tc.name: MetaTableTest 788 * @tc.desc: Meta table test 789 * @tc.type: FUNC 790 */ 791 HWTEST_F(TableTest, MetaTableTest, TestSize.Level1) 792 { 793 TS_LOGI("test31-22"); 794 std::string sqlSelect = "select * from meta"; 795 796 stream_.traceDataCache_->GetMetaData(); 797 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 798 EXPECT_EQ(row, 9); 799 } 800 /** 801 * @tc.name: NativeHookTableTest 802 * @tc.desc: Native hook table test 803 * @tc.type: FUNC 804 */ 805 HWTEST_F(TableTest, NativeHookTableTest, TestSize.Level1) 806 { 807 TS_LOGI("test31-23"); 808 std::string sqlSelect = "select * from native_hook"; 809 std::string sqlSelect1 = "select * from native_hook where id = 1"; 810 std::string sqlSelect2 = "select * from native_hook where ipid > 1"; 811 std::string sqlSelect3 = "select * from native_hook where itid >= 1"; 812 std::string sqlSelect4 = "select * from native_hook where callchain_id < 1"; 813 uint64_t callChainId = 1; 814 uint32_t ipid = 1; 815 uint32_t itid = 1; 816 std::string eventType = "eventType"; 817 DataIndex subType = stream_.traceDataCache_->GetDataIndex("subType"); 818 uint64_t timestamp = 1663869124160; 819 uint64_t endTimestamp = 1663869124360; 820 uint64_t duration = 200; 821 uint64_t addr = 1; 822 int64_t memSize = 1; 823 int64_t curMemSize = 1; 824 825 uint64_t callChainId1 = 2; 826 uint32_t ipid1 = 2; 827 uint32_t itid1 = 2; 828 std::string eventType1 = "eventType1"; 829 DataIndex subType1 = stream_.traceDataCache_->GetDataIndex("subType1"); 830 uint64_t timestamp1 = 1663869224160; 831 uint64_t endTimestamp1 = 1663869224360; 832 uint64_t duration1 = 200; 833 uint64_t addr1 = 2; 834 int64_t memSize1 = 2; 835 int64_t curMemSize1 = 2; 836 837 stream_.traceDataCache_->GetNativeHookData()->AppendNewNativeHookData( 838 callChainId, ipid, itid, eventType, subType, timestamp, endTimestamp, duration, addr, memSize, curMemSize); 839 stream_.traceDataCache_->GetNativeHookData()->AppendNewNativeHookData(callChainId1, ipid1, itid1, 840 eventType1, subType1, timestamp1, endTimestamp1, duration1, addr1, memSize1, curMemSize1); 841 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 842 EXPECT_EQ(row, 2); 843 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 844 EXPECT_EQ(row, 1); 845 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 846 EXPECT_EQ(row, 1); 847 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 848 EXPECT_EQ(row, 0); 849 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 850 EXPECT_EQ(row, 0); 851 } 852 /** 853 * @tc.name: NativeHookFrameTableTest 854 * @tc.desc: Native hook Frame table test 855 * @tc.type: FUNC 856 */ 857 HWTEST_F(TableTest, NativeHookFrameTableTest, TestSize.Level1) 858 { 859 TS_LOGI("test31-24"); 860 std::string sqlSelect = "select * from native_hook_frame"; 861 std::string sqlSelect1 = "select * from native_hook_frame where id = 1"; 862 std::string sqlSelect2 = "select * from native_hook_frame where callchain_id > 1"; 863 std::string sqlSelect3 = "select * from native_hook_frame where symbol_id >= 1"; 864 std::string sqlSelect4 = "select * from native_hook_frame where file_id < 2"; 865 uint64_t callChainId = 1; 866 uint64_t depth = 1; 867 uint64_t ip = 1; 868 uint64_t sp = 1; 869 DataIndex symbolName = stream_.traceDataCache_->GetDataIndex("symbolName"); 870 DataIndex filePath = stream_.traceDataCache_->GetDataIndex("filePath"); 871 uint64_t offset = 1; 872 uint64_t symbolOffset = 1; 873 874 uint64_t callChainId1 = 2; 875 uint64_t depth1 = 2; 876 uint64_t ip1 = 2; 877 uint64_t sp1 = 2; 878 DataIndex symbolName1 = stream_.traceDataCache_->GetDataIndex("symbolName1"); 879 DataIndex filePath1 = stream_.traceDataCache_->GetDataIndex("filePath1"); 880 uint64_t offset1 = 2; 881 uint64_t symbolOffset1 = 2; 882 883 stream_.traceDataCache_->GetNativeHookFrameData()->AppendNewNativeHookFrame(callChainId, depth, ip, sp, symbolName, 884 filePath, offset, symbolOffset); 885 stream_.traceDataCache_->GetNativeHookFrameData()->AppendNewNativeHookFrame( 886 callChainId1, depth1, ip1, sp1, symbolName1, filePath1, offset1, symbolOffset1); 887 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 888 EXPECT_EQ(row, 2); 889 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 890 EXPECT_EQ(row, 1); 891 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 892 EXPECT_EQ(row, 1); 893 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 894 EXPECT_EQ(row, 0); 895 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 896 EXPECT_EQ(row, 0); 897 } 898 /** 899 * @tc.name: NetworkTableTest 900 * @tc.desc: Network table test 901 * @tc.type: FUNC 902 */ 903 HWTEST_F(TableTest, NetworkTableTest, TestSize.Level1) 904 { 905 TS_LOGI("test31-25"); 906 std::string sqlSelect = "select * from network"; 907 uint64_t newTimeStamp = 1663869124160; 908 uint64_t tx = 1; 909 uint64_t rx = 1; 910 uint64_t dur = 200; 911 double rxSpeed = 1; 912 double txSpeed = 1; 913 uint64_t packetIn = 1; 914 double packetInSec = 1; 915 uint64_t packetOut = 1; 916 double packetOutSec = 1; 917 const std::string& netType = "nettype"; 918 919 stream_.traceDataCache_->GetNetworkData()->AppendNewNetData(newTimeStamp, tx, rx, dur, rxSpeed, txSpeed, packetIn, 920 packetInSec, packetOut, packetOutSec, netType); 921 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 922 EXPECT_EQ(row, 1); 923 } 924 /** 925 * @tc.name: PerfCallchainTableTest 926 * @tc.desc: Perf callchain table test 927 * @tc.type: FUNC 928 */ 929 HWTEST_F(TableTest, PerfCallchainTableTest, TestSize.Level1) 930 { 931 TS_LOGI("test31-26"); 932 std::string sqlSelect = "select * from perf_callchain"; 933 std::string sqlSelect1 = "select * from perf_callchain where id = 1"; 934 std::string sqlSelect2 = "select * from perf_callchain where callchain_id > 1"; 935 std::string sqlSelect3 = "select * from perf_callchain where file_id < 1"; 936 std::string sqlSelect4 = "select * from perf_callchain where symbol_id >= 1"; 937 uint64_t sampleId = stream_.traceDataCache_->GetDataIndex("sample"); 938 uint64_t callChainId = stream_.traceDataCache_->GetDataIndex("callChain"); 939 uint64_t vaddrInFile = 1; 940 uint64_t fileId = stream_.traceDataCache_->GetDataIndex("file"); 941 uint64_t symbolId = stream_.traceDataCache_->GetDataIndex("symbolId"); 942 943 uint64_t sampleId1 = stream_.traceDataCache_->GetDataIndex("sample1"); 944 uint64_t callChainId1 = stream_.traceDataCache_->GetDataIndex("callChain1"); 945 uint64_t vaddrInFile1 = 2; 946 uint64_t fileId1 = stream_.traceDataCache_->GetDataIndex("file1"); 947 uint64_t symbolId1 = stream_.traceDataCache_->GetDataIndex("symbolId1"); 948 949 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(sampleId, callChainId, vaddrInFile, fileId, 950 symbolId); 951 952 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(sampleId1, callChainId1, 953 vaddrInFile1, fileId1, symbolId1); 954 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 955 EXPECT_EQ(row, 2); 956 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 957 EXPECT_EQ(row, 1); 958 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 959 EXPECT_EQ(row, 2); 960 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 961 EXPECT_EQ(row, 0); 962 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 963 EXPECT_EQ(row, 0); 964 } 965 /** 966 * @tc.name: PerfFilesTableTest 967 * @tc.desc: Perf files table test 968 * @tc.type: FUNC 969 */ 970 HWTEST_F(TableTest, PerfFilesTableTest, TestSize.Level1) 971 { 972 TS_LOGI("test31-27"); 973 std::string sqlSelect = "select * from perf_files"; 974 std::string sqlSelect1 = "select * from perf_files where id = 1"; 975 std::string sqlSelect2 = "select * from perf_files where file_id < 1"; 976 uint64_t fileIds = stream_.traceDataCache_->GetDataIndex("file"); 977 uint32_t serial = 1; 978 DataIndex symbols = stream_.traceDataCache_->GetDataIndex("symbol"); 979 DataIndex filePath = stream_.traceDataCache_->GetDataIndex("filePath"); 980 981 uint64_t fileIds1 = stream_.traceDataCache_->GetDataIndex("file1"); 982 uint32_t serial1 = 1; 983 DataIndex symbols1 = stream_.traceDataCache_->GetDataIndex("symbol1"); 984 DataIndex filePath1 = stream_.traceDataCache_->GetDataIndex("filePath1"); 985 986 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds, serial, symbols, filePath); 987 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds1, serial1, symbols1, filePath1); 988 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 989 EXPECT_EQ(row, 2); 990 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 991 EXPECT_EQ(row, 1); 992 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 993 EXPECT_EQ(row, 0); 994 } 995 /** 996 * @tc.name: PerfReportTableTest 997 * @tc.desc: Perf report table test 998 * @tc.type: FUNC 999 */ 1000 HWTEST_F(TableTest, PerfReportTableTest, TestSize.Level1) 1001 { 1002 TS_LOGI("test31-28"); 1003 std::string sqlSelect = "select * from perf_report"; 1004 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1005 DataIndex value = stream_.traceDataCache_->GetDataIndex("value"); 1006 1007 stream_.traceDataCache_->GetPerfReportData()->AppendNewPerfReport(type, value); 1008 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1009 EXPECT_EQ(row, 1); 1010 } 1011 /** 1012 * @tc.name: PerfSampleTableTest 1013 * @tc.desc: Perf sample table test 1014 * @tc.type: FUNC 1015 */ 1016 HWTEST_F(TableTest, PerfSampleTableTest, TestSize.Level1) 1017 { 1018 TS_LOGI("test31-29"); 1019 std::string sqlSelect = "select * from perf_sample"; 1020 std::string sqlSelect1 = "select * from perf_sample where id = 1"; 1021 std::string sqlSelect2 = "select * from perf_sample where callchain_id > 1"; 1022 std::string sqlSelect3 = "select * from perf_sample where thread_id < 1"; 1023 std::string sqlSelect4 = "select * from perf_sample where event_type_id >= 1"; 1024 std::string sqlSelect5 = "select * from perf_sample where cpu_id <= 1"; 1025 uint64_t sampleId = stream_.traceDataCache_->GetDataIndex("type"); 1026 uint64_t timestamp = 1663869124160; 1027 uint64_t tid = 1; 1028 uint64_t eventCount = 2; 1029 uint64_t eventTypeId = 1; 1030 uint64_t timestampTrace = 1; 1031 uint64_t cpuId = 1; 1032 uint64_t threadState = stream_.traceDataCache_->GetDataIndex("threadState"); 1033 1034 uint64_t sampleId1 = stream_.traceDataCache_->GetDataIndex("type1"); 1035 uint64_t timestamp1 = 1663869124160; 1036 uint64_t tid1 = 2; 1037 uint64_t eventCount1 = 3; 1038 uint64_t eventTypeId1 = 2; 1039 uint64_t timestampTrace1 = 2; 1040 uint64_t cpuId1 = 2; 1041 uint64_t threadState1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 1042 1043 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample(sampleId, timestamp, tid, eventCount, eventTypeId, 1044 timestampTrace, cpuId, threadState); 1045 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample( 1046 sampleId1, timestamp1, tid1, eventCount1, eventTypeId1, timestampTrace1, cpuId1, threadState1); 1047 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1048 EXPECT_EQ(row, 2); 1049 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1050 EXPECT_EQ(row, 1); 1051 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1052 EXPECT_EQ(row, 2); 1053 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1054 EXPECT_EQ(row, 0); 1055 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1056 EXPECT_EQ(row, 0); 1057 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1058 EXPECT_EQ(row, 1); 1059 } 1060 /** 1061 * @tc.name: PerfThreadTableTest 1062 * @tc.desc: Perf Thread table test 1063 * @tc.type: FUNC 1064 */ 1065 HWTEST_F(TableTest, PerfThreadTableTest, TestSize.Level1) 1066 { 1067 TS_LOGI("test31-30"); 1068 std::string sqlSelect = "select * from perf_thread"; 1069 std::string sqlSelect1 = "select * from perf_thread where id = 1"; 1070 std::string sqlSelect2 = "select * from perf_thread where thread_id > 1"; 1071 std::string sqlSelect3 = "select * from perf_thread where process_id < 1"; 1072 uint64_t pid = 1; 1073 uint64_t tid = 1; 1074 DataIndex threadName = stream_.traceDataCache_->GetDataIndex("threadState"); 1075 1076 uint64_t pid1 = 2; 1077 uint64_t tid1 = 2; 1078 DataIndex threadName1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 1079 1080 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid, tid, threadName); 1081 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid1, tid1, threadName1); 1082 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1083 EXPECT_EQ(row, 2); 1084 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1085 EXPECT_EQ(row, 1); 1086 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1087 EXPECT_EQ(row, 1); 1088 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1089 EXPECT_EQ(row, 0); 1090 } 1091 /** 1092 * @tc.name: ProcessTableTest 1093 * @tc.desc: Process table test 1094 * @tc.type: FUNC 1095 */ 1096 HWTEST_F(TableTest, ProcessTableTest, TestSize.Level1) 1097 { 1098 TS_LOGI("test31-31"); 1099 std::string sqlSelect = "select * from process"; 1100 std::string sqlSelect1 = "select * from process where id = 1"; 1101 1102 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1103 EXPECT_EQ(row, 1); 1104 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1105 EXPECT_EQ(row, 0); 1106 } 1107 /** 1108 * @tc.name: ProcessFilterTableTest 1109 * @tc.desc: Process filter table test 1110 * @tc.type: FUNC 1111 */ 1112 HWTEST_F(TableTest, ProcessFilterTableTest, TestSize.Level1) 1113 { 1114 TS_LOGI("test31-32"); 1115 std::string sqlSelect = "select * from process_filter"; 1116 uint64_t id = 1; 1117 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 1118 uint32_t internalPid = 1; 1119 1120 stream_.traceDataCache_->GetProcessFilterData()->AppendNewFilter(id, name, internalPid); 1121 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1122 EXPECT_EQ(row, 1); 1123 } 1124 /** 1125 * @tc.name: ProcessMeasureTableTest 1126 * @tc.desc: Process Measure table test 1127 * @tc.type: FUNC 1128 */ 1129 HWTEST_F(TableTest, ProcessMeasureTableTest, TestSize.Level1) 1130 { 1131 TS_LOGI("test31-33"); 1132 std::string sqlSelect = "select * from process_measure"; 1133 uint32_t type = 1; 1134 uint64_t timestamp = 1663869124160; 1135 int64_t value = 1; 1136 uint32_t filterId = 1; 1137 1138 stream_.traceDataCache_->GetProcessMeasureData()->AppendMeasureData(type, timestamp, value, filterId); 1139 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1140 EXPECT_EQ(row, 1); 1141 } 1142 /** 1143 * @tc.name: ProcessMeasureFilterTableTest 1144 * @tc.desc: Process Measure filter table test 1145 * @tc.type: FUNC 1146 */ 1147 HWTEST_F(TableTest, ProcessMeasureFilterTableTest, TestSize.Level1) 1148 { 1149 TS_LOGI("test31-34"); 1150 std::string sqlSelect = "select * from process_measure_filter"; 1151 std::string sqlSelect1 = "select * from process_measure_filter where id = 1"; 1152 std::string sqlSelect2 = "select * from process_measure_filter where ipid < 1"; 1153 std::string sqlSelect3 = "select * from process_measure_filter where name = \"name\""; 1154 uint64_t id = 1; 1155 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 1156 uint32_t internalPid = 1; 1157 1158 uint64_t id1 = 1; 1159 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 1160 uint32_t internalPid1 = 1; 1161 1162 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id, name, internalPid); 1163 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id1, name1, internalPid1); 1164 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1165 EXPECT_EQ(row, 2); 1166 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1167 EXPECT_EQ(row, 2); 1168 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1169 EXPECT_EQ(row, 0); 1170 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1171 EXPECT_EQ(row, 2); 1172 } 1173 /** 1174 * @tc.name: RawTableTest 1175 * @tc.desc: Raw table test 1176 * @tc.type: FUNC 1177 */ 1178 HWTEST_F(TableTest, RawTableTest, TestSize.Level1) 1179 { 1180 TS_LOGI("test31-35"); 1181 std::string sqlSelect = "select * from raw"; 1182 std::string sqlSelect1 = "select * from raw where id = 1"; 1183 std::string sqlSelect2 = "select * from raw where name = \"sched_waking\""; 1184 std::string sqlSelect3 = "select * from raw where ts = 1663869124160"; 1185 std::string sqlSelect4 = "select * from raw where itid < 2"; 1186 uint32_t id = 1; 1187 uint64_t timestamp = 1663869124160; 1188 uint32_t name = stream_.traceDataCache_->GetDataIndex("cpu_idle"); 1189 uint32_t cpu = 1; 1190 uint32_t internalTid = 1; 1191 1192 uint32_t id1 = 2; 1193 uint64_t timestamp1 = 1663869224160; 1194 uint32_t name1 = stream_.traceDataCache_->GetDataIndex("sched_waking"); 1195 uint32_t cpu1 = 2; 1196 uint32_t internalTid1 = 2; 1197 1198 stream_.traceDataCache_->GetRawData()->AppendRawData(id, timestamp, name, cpu, internalTid); 1199 stream_.traceDataCache_->GetRawData()->AppendRawData(id1, timestamp1, name1, cpu1, internalTid1); 1200 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1201 EXPECT_EQ(row, 2); 1202 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1203 EXPECT_EQ(row, 1); 1204 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1205 EXPECT_EQ(row, 0); 1206 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1207 EXPECT_EQ(row, 1); 1208 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1209 EXPECT_EQ(row, 0); 1210 } 1211 /** 1212 * @tc.name: SchedSliceTest 1213 * @tc.desc: Sched slice table test 1214 * @tc.type: FUNC 1215 */ 1216 HWTEST_F(TableTest, SchedSliceTest, TestSize.Level1) 1217 { 1218 TS_LOGI("test31-36"); 1219 std::string sqlSelect = "select * from sched_slice"; 1220 std::string sqlSelect1 = "select * from sched_slice where id = 1"; 1221 std::string sqlSelect2 = "select * from sched_slice where ts > 1"; 1222 std::string sqlSelect3 = "select * from sched_slice where cpu < 1"; 1223 std::string sqlSelect4 = "select * from sched_slice where itid >= 1"; 1224 std::string sqlSelect5 = "select * from sched_slice where ipid <= 1"; 1225 std::string sqlSelect6 = "select * from sched_slice where dur >= 200"; 1226 uint64_t ts = 1663869124160; 1227 uint64_t dur = 200; 1228 uint64_t cpu = 1; 1229 uint64_t internalTid = 1; 1230 uint64_t endState = 1; 1231 uint64_t priority = 1; 1232 1233 uint64_t ts1 = 1663869224160; 1234 uint64_t dur1 = 200; 1235 uint64_t cpu1 = 2; 1236 uint64_t internalTid1 = 2; 1237 uint64_t endState1 = 2; 1238 uint64_t priority1 = 2; 1239 1240 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(ts, dur, cpu, internalTid, endState, priority); 1241 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(ts1, dur1, cpu1, internalTid1, endState1, priority1); 1242 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1243 EXPECT_EQ(row, 2); 1244 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1245 EXPECT_EQ(row, 1); 1246 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1247 EXPECT_EQ(row, 2); 1248 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1249 EXPECT_EQ(row, 0); 1250 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1251 EXPECT_EQ(row, 0); 1252 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1253 EXPECT_EQ(row, 0); 1254 row = stream_.traceDataCache_->SearchDatabase(sqlSelect6.c_str(), false); 1255 EXPECT_EQ(row, 0); 1256 } 1257 /** 1258 * @tc.name: SmapsTest 1259 * @tc.desc: Smaps table test 1260 * @tc.type: FUNC 1261 */ 1262 HWTEST_F(TableTest, SmapsTest, TestSize.Level1) 1263 { 1264 TS_LOGI("test31-37"); 1265 std::string sqlSelect = "select * from smaps"; 1266 uint64_t timeStamp = 1663869124160; 1267 std::string startAddr = "startAddr"; 1268 std::string endAddr = "endAddr"; 1269 uint64_t dirty = 1; 1270 uint64_t swapper = 1; 1271 uint64_t rss = 1; 1272 uint64_t pss = 1; 1273 uint64_t size = 2; 1274 double reside = 1; 1275 DataIndex protectionId = stream_.traceDataCache_->GetDataIndex("protection"); 1276 DataIndex pathId = stream_.traceDataCache_->GetDataIndex("path"); 1277 1278 stream_.traceDataCache_->GetSmapsData()->AppendNewData(timeStamp, startAddr, endAddr, dirty, swapper, rss, pss, 1279 size, reside, protectionId, pathId); 1280 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1281 EXPECT_EQ(row, 1); 1282 } 1283 /** 1284 * @tc.name: StatTableTest 1285 * @tc.desc: Stat table test 1286 * @tc.type: FUNC 1287 */ 1288 HWTEST_F(TableTest, StatTableTest, TestSize.Level1) 1289 { 1290 TS_LOGI("test31-38"); 1291 std::string sqlSelect = "select * from stat"; 1292 stream_.traceDataCache_->GetStatAndInfo(); 1293 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1294 EXPECT_EQ(row, 395); 1295 } 1296 /** 1297 * @tc.name: SymbolsTableTest 1298 * @tc.desc: Symbols table test 1299 * @tc.type: FUNC 1300 */ 1301 HWTEST_F(TableTest, SymbolsTableTest, TestSize.Level1) 1302 { 1303 TS_LOGI("test31-39"); 1304 std::string sqlSelect = "select * from symbols"; 1305 std::string sqlSelect1 = "select * from symbols where id = 1"; 1306 std::string sqlSelect2 = "select * from symbols where id < 1"; 1307 const DataIndex& name = stream_.traceDataCache_->GetDataIndex("name"); 1308 const uint64_t& addr = 1; 1309 1310 const DataIndex& name1 = stream_.traceDataCache_->GetDataIndex("name1"); 1311 const uint64_t& addr1 = 2; 1312 1313 stream_.traceDataCache_->GetSymbolsData()->InsertSymbol(name, addr); 1314 stream_.traceDataCache_->GetSymbolsData()->InsertSymbol(name1, addr1); 1315 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1316 EXPECT_EQ(row, 2); 1317 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1318 EXPECT_EQ(row, 1); 1319 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1320 EXPECT_EQ(row, 1); 1321 } 1322 /** 1323 * @tc.name: SyscallTableTest 1324 * @tc.desc: Syscall table test 1325 * @tc.type: FUNC 1326 */ 1327 HWTEST_F(TableTest, SyscallTableTest, TestSize.Level1) 1328 { 1329 TS_LOGI("test31-40"); 1330 std::string sqlSelect = "select * from syscall"; 1331 int64_t sysCallNum = 1; 1332 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1333 uint64_t ipid = 1; 1334 uint64_t timestamp = 1663869124160; 1335 int64_t ret = 1; 1336 1337 stream_.traceDataCache_->GetSysCallData()->AppendSysCallData(sysCallNum, type, ipid, timestamp, ret); 1338 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1339 EXPECT_EQ(row, 1); 1340 } 1341 /** 1342 * @tc.name: SysEventFilterTableTest 1343 * @tc.desc: SysEventFilter table test 1344 * @tc.type: FUNC 1345 */ 1346 HWTEST_F(TableTest, SysEventFilterTableTest, TestSize.Level1) 1347 { 1348 TS_LOGI("test31-41"); 1349 std::string sqlSelect = "select * from sys_event_filter"; 1350 std::string sqlSelect1 = "select * from sys_event_filter where id = 1"; 1351 std::string sqlSelect2 = "select * from sys_event_filter where id > 1"; 1352 std::string sqlSelect3 = "select * from sys_event_filter where id < 1"; 1353 std::string sqlSelect4 = "select * from sys_event_filter where id >= 1"; 1354 std::string sqlSelect5 = "select * from sys_event_filter where id <= 1"; 1355 uint64_t filterId = 1; 1356 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 1357 DataIndex nameId = stream_.traceDataCache_->GetDataIndex("name"); 1358 1359 uint64_t filterId1 = 2; 1360 DataIndex type1 = stream_.traceDataCache_->GetDataIndex("type1"); 1361 DataIndex nameId1 = stream_.traceDataCache_->GetDataIndex("name1"); 1362 1363 stream_.traceDataCache_->GetSysMeasureFilterData()->AppendNewFilter(filterId, type, nameId); 1364 stream_.traceDataCache_->GetSysMeasureFilterData()->AppendNewFilter(filterId1, type1, nameId1); 1365 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1366 EXPECT_EQ(row, 2); 1367 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1368 EXPECT_EQ(row, 1); 1369 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1370 EXPECT_EQ(row, 1); 1371 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1372 EXPECT_EQ(row, 1); 1373 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1374 EXPECT_EQ(row, 2); 1375 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1376 EXPECT_EQ(row, 2); 1377 } 1378 /** 1379 * @tc.name: SysMemMeasureTableTest 1380 * @tc.desc: SysMemMeasure table test 1381 * @tc.type: FUNC 1382 */ 1383 HWTEST_F(TableTest, SysMemMeasureTableTest, TestSize.Level1) 1384 { 1385 TS_LOGI("test31-42"); 1386 std::string sqlSelect = "select * from sys_mem_measure"; 1387 uint32_t type = 1; 1388 uint64_t timestamp = 1663869124160; 1389 int64_t value = 1; 1390 uint32_t filterId = stream_.traceDataCache_->GetDataIndex("filter"); 1391 1392 stream_.traceDataCache_->GetSysMemMeasureData()->AppendMeasureData(type, timestamp, value, filterId); 1393 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1394 EXPECT_EQ(row, 1); 1395 } 1396 /** 1397 * @tc.name: ThreadTableTest 1398 * @tc.desc: Thread table test 1399 * @tc.type: FUNC 1400 */ 1401 HWTEST_F(TableTest, ThreadTableTest, TestSize.Level1) 1402 { 1403 TS_LOGI("test31-43"); 1404 std::string sqlSelect = "select * from thread"; 1405 1406 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1407 EXPECT_EQ(row, 1); 1408 } 1409 /** 1410 * @tc.name: ThreadFilterTableTest 1411 * @tc.desc: ThreadFilter table test 1412 * @tc.type: FUNC 1413 */ 1414 HWTEST_F(TableTest, ThreadFilterTableTest, TestSize.Level1) 1415 { 1416 TS_LOGI("test31-44"); 1417 std::string sqlSelect = "select * from thread_filter"; 1418 uint64_t filterId = stream_.traceDataCache_->GetDataIndex("ilter"); 1419 uint32_t nameIndex = stream_.traceDataCache_->GetDataIndex("name"); 1420 uint64_t internalTid = 1; 1421 1422 stream_.traceDataCache_->GetThreadFilterData()->AppendNewFilter(filterId, nameIndex, internalTid); 1423 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1424 EXPECT_EQ(row, 1); 1425 } 1426 /** 1427 * @tc.name: ThreadStateTableTest 1428 * @tc.desc: ThreadState table test 1429 * @tc.type: FUNC 1430 */ 1431 HWTEST_F(TableTest, ThreadStateTableTest, TestSize.Level1) 1432 { 1433 TS_LOGI("test31-45"); 1434 std::string sqlSelect = "select * from thread_state"; 1435 std::string sqlSelect1 = "select * from thread_state where id = 1"; 1436 std::string sqlSelect2 = "select * from thread_state where tid > 1"; 1437 std::string sqlSelect3 = "select * from thread_state where pid < 1"; 1438 std::string sqlSelect4 = "select * from thread_state where itid >= 1"; 1439 std::string sqlSelect5 = "select * from thread_state where cpu <= 1"; 1440 std::string sqlSelect6 = "select * from thread_state where ts = 1663869124160"; 1441 std::string sqlSelect7 = "select * from thread_state where dur = 1"; 1442 std::string sqlSelect8 = "select * from thread_state where state = \"idState\""; 1443 InternalTime ts = 1663869124160; 1444 InternalTime dur = 200; 1445 InternalCpu cpu = 1; 1446 InternalTid itid = 1; 1447 TableRowId idState = 1; 1448 1449 InternalTime ts1 = 1663869224160; 1450 InternalTime dur1 = 200; 1451 InternalCpu cpu1 = 2; 1452 InternalTid itid1 = 2; 1453 TableRowId idState1 = 2; 1454 1455 stream_.traceDataCache_->GetThreadStateData()->AppendThreadState(ts, dur, cpu, itid, idState); 1456 stream_.traceDataCache_->GetThreadStateData()->AppendThreadState(ts1, dur1, cpu1, itid1, idState1); 1457 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1458 EXPECT_EQ(row, 2); 1459 row = stream_.traceDataCache_->SearchDatabase(sqlSelect1.c_str(), false); 1460 EXPECT_EQ(row, 1); 1461 row = stream_.traceDataCache_->SearchDatabase(sqlSelect2.c_str(), false); 1462 EXPECT_EQ(row, 2); 1463 row = stream_.traceDataCache_->SearchDatabase(sqlSelect3.c_str(), false); 1464 EXPECT_EQ(row, 0); 1465 row = stream_.traceDataCache_->SearchDatabase(sqlSelect4.c_str(), false); 1466 EXPECT_EQ(row, 0); 1467 row = stream_.traceDataCache_->SearchDatabase(sqlSelect5.c_str(), false); 1468 EXPECT_EQ(row, 1); 1469 row = stream_.traceDataCache_->SearchDatabase(sqlSelect6.c_str(), false); 1470 EXPECT_EQ(row, 1); 1471 row = stream_.traceDataCache_->SearchDatabase(sqlSelect7.c_str(), false); 1472 EXPECT_EQ(row, 0); 1473 row = stream_.traceDataCache_->SearchDatabase(sqlSelect8.c_str(), false); 1474 EXPECT_EQ(row, 0); 1475 } 1476 /** 1477 * @tc.name: TraceRangeTableTest 1478 * @tc.desc: TraceRange table test 1479 * @tc.type: FUNC 1480 */ 1481 HWTEST_F(TableTest, TraceRangeTableTest, TestSize.Level1) 1482 { 1483 TS_LOGI("test31-46"); 1484 std::string sqlSelect = "select * from trace_range"; 1485 1486 stream_.traceDataCache_->UpdateTraceRange(); 1487 auto row = stream_.traceDataCache_->SearchDatabase(sqlSelect.c_str(), false); 1488 EXPECT_EQ(row, 1); 1489 } 1490 } // namespace TraceStreamer 1491 } // namespace SysTuning 1492