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