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