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 24using namespace testing::ext; 25using namespace SysTuning::TraceStreamer; 26namespace SysTuning { 27namespace TraceStreamer { 28const uint64_t CALLCHAIN_ID = 1; 29const uint16_t TYPE = 1; 30const uint32_t IPID = 1; 31const uint32_t ITID = 1; 32const uint64_t START_TS = 1663869124160; 33const uint64_t END_TS = 1663869124260; 34const uint64_t DUR = 100; 35const size_t SIZE = 1; 36const int32_t FD = 0; 37const uint64_t TIMESTAMP = 1663869124160; 38const uint32_t FPS = 1; 39const uint64_t CALLCHAIN_ID1 = 2; 40const uint16_t TYPE1 = 2; 41const uint32_t IPID1 = 2; 42const uint32_t ITID1 = 2; 43const uint64_t START_TS1 = 1663869124161; 44const uint64_t END_TS1 = 1663869124261; 45const uint64_t DUR1 = 200; 46const size_t SIZE1 = 2; 47const int32_t FD1 = 1; 48const uint64_t TIMESTAMP1 = 1663869224160; 49const uint32_t FPS1 = 2; 50 51class TableTest : public ::testing::Test { 52public: 53 void SetUp() 54 { 55 stream_.InitFilter(); 56 } 57 void TearDown() {} 58 59public: 60 TraceStreamerSelector stream_ = {}; 61}; 62 63/** 64 * @tc.name: AppnameTableTest 65 * @tc.desc: Appname Table Test 66 * @tc.type: FUNC 67 */ 68HWTEST_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 */ 83HWTEST_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 */ 115HWTEST_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 */ 160HWTEST_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 */ 192HWTEST_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 */ 225HWTEST_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 */ 257HWTEST_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 */ 293HWTEST_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 */ 315HWTEST_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 */ 349HWTEST_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 */ 372HWTEST_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 */ 413HWTEST_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 */ 461HWTEST_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 */ 476HWTEST_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 = {ts, nameId, keyId, type, numericValue, stringValue, serial}; 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 */ 496HWTEST_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 */ 542HWTEST_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 uint64_t callChainId1 = 2; 558 uint64_t type1 = 2; 559 uint64_t ipid1 = 2; 560 uint64_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 GetBioLatencySampleDataRow 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 */ 594HWTEST_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 */ 627HWTEST_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 */ 659HWTEST_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 */ 680HWTEST_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 */ 705HWTEST_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 */ 721HWTEST_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 */ 734HWTEST_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 uint64_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 */ 780HWTEST_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 uint64_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 uint64_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 = {CALLCHAIN_ID1, depth1, ip1, symbolName1, filePath1, offset1, symbolOffset1, vaddr1}; 807 stream_.traceDataCache_->GetNativeHookFrameData()->AppendNewNativeHookFrame(nativeHookFrameVaddrRow); 808 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 809 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 810 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 1); 811 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 2); 812 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect4, false), 0); 813} 814/** 815 * @tc.name: NetworkTableTest 816 * @tc.desc: Network table test 817 * @tc.type: FUNC 818 */ 819HWTEST_F(TableTest, NetworkTableTest, TestSize.Level1) 820{ 821 TS_LOGI("test31-25"); 822 std::string sqlSelect = "select * from network"; 823 const uint64_t newTimeStamp = 1663869124160; 824 const uint64_t dur = 200; 825 const std::string &netType = "nettype"; 826 827 NetDetailRow row; 828 row.newTimeStamp = newTimeStamp; 829 row.tx = 1; 830 row.rx = 1; 831 row.dur = dur; 832 row.rxSpeed = 1; 833 row.txSpeed = 1; 834 row.packetIn = 1; 835 row.packetInSec = 1; 836 row.packetOut = 1; 837 row.packetOutSec = 1; 838 row.netType = netType; 839 stream_.traceDataCache_->GetNetworkData()->AppendNewNetData(row); 840 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 1); 841} 842/** 843 * @tc.name: PerfCallchainTableTest 844 * @tc.desc: Perf callchain table test 845 * @tc.type: FUNC 846 */ 847HWTEST_F(TableTest, PerfCallchainTableTest, TestSize.Level1) 848{ 849 TS_LOGI("test31-26"); 850 std::string sqlSelect = "select * from perf_callchain"; 851 std::string sqlSelect1 = "select * from perf_callchain where id = 1"; 852 std::string sqlSelect2 = "select * from perf_callchain where callchain_id > 1"; 853 std::string sqlSelect3 = "select * from perf_callchain where file_id < 1"; 854 std::string sqlSelect4 = "select * from perf_callchain where symbol_id >= 1"; 855 uint64_t callChainId = stream_.traceDataCache_->GetDataIndex("callChain"); 856 uint32_t depth = 0; 857 uint64_t ip = 123; 858 uint64_t vaddrInFile = 1; 859 uint64_t fileId = stream_.traceDataCache_->GetDataIndex("file"); 860 uint64_t symbolId = stream_.traceDataCache_->GetDataIndex("symbolId"); 861 862 uint64_t callChainId1 = 2; 863 uint32_t depth1 = 1; 864 uint64_t ip1 = 234; 865 uint64_t vaddrInFile1 = 2; 866 uint64_t fileId1 = stream_.traceDataCache_->GetDataIndex("file1"); 867 uint64_t symbolId1 = stream_.traceDataCache_->GetDataIndex("symbolId1"); 868 PerfCallChainRow perfCallChainRow = {callChainId, depth, vaddrInFile, ip, fileId, symbolId}; 869 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(perfCallChainRow); 870 perfCallChainRow = {callChainId1, depth1, vaddrInFile1, ip1, fileId1, symbolId1}; 871 stream_.traceDataCache_->GetPerfCallChainData()->AppendNewPerfCallChain(perfCallChainRow); 872 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 873 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 874 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 2); 875 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 0); 876 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect4, false), 2); 877} 878/** 879 * @tc.name: PerfFilesTableTest 880 * @tc.desc: Perf files table test 881 * @tc.type: FUNC 882 */ 883HWTEST_F(TableTest, PerfFilesTableTest, TestSize.Level1) 884{ 885 TS_LOGI("test31-27"); 886 std::string sqlSelect = "select * from perf_files"; 887 std::string sqlSelect1 = "select * from perf_files where id = 1"; 888 std::string sqlSelect2 = "select * from perf_files where file_id < 1"; 889 uint64_t fileIds = stream_.traceDataCache_->GetDataIndex("file"); 890 uint32_t serial = 1; 891 DataIndex symbols = stream_.traceDataCache_->GetDataIndex("symbol"); 892 DataIndex filePath = stream_.traceDataCache_->GetDataIndex("filePath"); 893 894 uint64_t fileIds1 = stream_.traceDataCache_->GetDataIndex("file1"); 895 uint32_t serial1 = 1; 896 DataIndex symbols1 = stream_.traceDataCache_->GetDataIndex("symbol1"); 897 DataIndex filePath1 = stream_.traceDataCache_->GetDataIndex("filePath1"); 898 899 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds, serial, symbols, filePath); 900 stream_.traceDataCache_->GetPerfFilesData()->AppendNewPerfFiles(fileIds1, serial1, symbols1, filePath1); 901 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 902 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 903 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 0); 904} 905/** 906 * @tc.name: PerfReportTableTest 907 * @tc.desc: Perf report table test 908 * @tc.type: FUNC 909 */ 910HWTEST_F(TableTest, PerfReportTableTest, TestSize.Level1) 911{ 912 TS_LOGI("test31-28"); 913 std::string sqlSelect = "select * from perf_report"; 914 DataIndex type = stream_.traceDataCache_->GetDataIndex("type"); 915 DataIndex value = stream_.traceDataCache_->GetDataIndex("value"); 916 917 stream_.traceDataCache_->GetPerfReportData()->AppendNewPerfReport(type, value); 918 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 1); 919} 920/** 921 * @tc.name: PerfSampleTableTest 922 * @tc.desc: Perf sample table test 923 * @tc.type: FUNC 924 */ 925HWTEST_F(TableTest, PerfSampleTableTest, TestSize.Level1) 926{ 927 TS_LOGI("test31-29"); 928 std::string sqlSelect = "select * from perf_sample"; 929 std::string sqlSelect1 = "select * from perf_sample where id = 1"; 930 std::string sqlSelect2 = "select * from perf_sample where callchain_id > 1"; 931 std::string sqlSelect3 = "select * from perf_sample where thread_id < 1"; 932 std::string sqlSelect4 = "select * from perf_sample where event_type_id >= 1"; 933 std::string sqlSelect5 = "select * from perf_sample where cpu_id <= 1"; 934 uint64_t sampleId = stream_.traceDataCache_->GetDataIndex("type"); 935 uint64_t timeStamp = 1663869124160; 936 uint64_t tid = 1; 937 uint64_t eventCount = 2; 938 uint64_t eventTypeId = 1; 939 uint64_t timestampTrace = 1; 940 uint64_t cpuId = 1; 941 uint64_t threadState = stream_.traceDataCache_->GetDataIndex("threadState"); 942 943 uint64_t sampleId1 = stream_.traceDataCache_->GetDataIndex("type1"); 944 uint64_t timestamp1 = 1663869124160; 945 uint64_t tid1 = 2; 946 uint64_t eventCount1 = 3; 947 uint64_t eventTypeId1 = 2; 948 uint64_t timestampTrace1 = 2; 949 uint64_t cpuId1 = 2; 950 uint64_t threadState1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 951 952 PerfSampleRow perfSampleRow = {sampleId, timestamp, tid, eventCount, 953 eventTypeId, timestampTrace, cpuId, threadState}; 954 PerfSampleRow perfSampleRow1 = {sampleId1, timestamp1, tid1, eventCount1, 955 eventTypeId1, timestampTrace1, cpuId1, threadState1}; 956 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample(perfSampleRow); 957 stream_.traceDataCache_->GetPerfSampleData()->AppendNewPerfSample(perfSampleRow1); 958 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 959 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 960 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 2); 961 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 0); 962 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect4, false), 2); 963 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect5, false), 1); 964} 965/** 966 * @tc.name: PerfThreadTableTest 967 * @tc.desc: Perf Thread table test 968 * @tc.type: FUNC 969 */ 970HWTEST_F(TableTest, PerfThreadTableTest, TestSize.Level1) 971{ 972 TS_LOGI("test31-30"); 973 std::string sqlSelect = "select * from perf_thread"; 974 std::string sqlSelect1 = "select * from perf_thread where id = 1"; 975 std::string sqlSelect2 = "select * from perf_thread where thread_id > 1"; 976 std::string sqlSelect3 = "select * from perf_thread where process_id < 1"; 977 uint64_t pid = 1; 978 uint64_t tid = 1; 979 DataIndex threadName = stream_.traceDataCache_->GetDataIndex("threadState"); 980 981 uint64_t pid1 = 2; 982 uint64_t tid1 = 2; 983 DataIndex threadName1 = stream_.traceDataCache_->GetDataIndex("threadState1"); 984 985 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid, tid, threadName); 986 stream_.traceDataCache_->GetPerfThreadData()->AppendNewPerfThread(pid1, tid1, threadName1); 987 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 988 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 989 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 1); 990 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 0); 991} 992/** 993 * @tc.name: ProcessTableTest 994 * @tc.desc: Process table test 995 * @tc.type: FUNC 996 */ 997HWTEST_F(TableTest, ProcessTableTest, TestSize.Level1) 998{ 999 TS_LOGI("test31-31"); 1000 std::string sqlSelect = "select * from process"; 1001 std::string sqlSelect1 = "select * from process where id = 1"; 1002 1003 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 1); 1004 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 0); 1005} 1006/** 1007 * @tc.name: ProcessMeasureTableTest 1008 * @tc.desc: Process Measure table test 1009 * @tc.type: FUNC 1010 */ 1011HWTEST_F(TableTest, ProcessMeasureTableTest, TestSize.Level1) 1012{ 1013 TS_LOGI("test31-32"); 1014 std::string sqlSelect = "select * from process_measure"; 1015 uint32_t type = 1; 1016 uint64_t timeStamp = 1663869124160; 1017 int64_t value = 1; 1018 uint32_t filterId = 1; 1019 1020 stream_.traceDataCache_->GetProcessMeasureData()->AppendMeasureData(type, timeStamp, value, filterId); 1021 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 1); 1022} 1023/** 1024 * @tc.name: ProcessMeasureFilterTableTest 1025 * @tc.desc: Process Measure filter table test 1026 * @tc.type: FUNC 1027 */ 1028HWTEST_F(TableTest, ProcessMeasureFilterTableTest, TestSize.Level1) 1029{ 1030 TS_LOGI("test31-33"); 1031 std::string sqlSelect = "select * from process_measure_filter"; 1032 std::string sqlSelect1 = "select * from process_measure_filter where id = 1"; 1033 std::string sqlSelect2 = "select * from process_measure_filter where ipid < 1"; 1034 std::string sqlSelect3 = "select * from process_measure_filter where name = \"name\""; 1035 uint64_t id = 1; 1036 DataIndex name = stream_.traceDataCache_->GetDataIndex("name"); 1037 uint32_t internalPid = 1; 1038 1039 uint64_t id1 = 1; 1040 DataIndex name1 = stream_.traceDataCache_->GetDataIndex("name1"); 1041 uint32_t internalPid1 = 1; 1042 1043 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id, name, internalPid); 1044 stream_.traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(id1, name1, internalPid1); 1045 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 1046 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 2); 1047 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 0); 1048 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 2); 1049} 1050/** 1051 * @tc.name: RawTableTest 1052 * @tc.desc: Raw table test 1053 * @tc.type: FUNC 1054 */ 1055HWTEST_F(TableTest, RawTableTest, TestSize.Level1) 1056{ 1057 TS_LOGI("test31-34"); 1058 std::string sqlSelect = "select * from raw"; 1059 std::string sqlSelect1 = "select * from raw where id = 1"; 1060 std::string sqlSelect2 = "select * from raw where name = \"sched_waking\""; 1061 std::string sqlSelect3 = "select * from raw where ts = 1663869124160"; 1062 std::string sqlSelect4 = "select * from raw where itid < 2"; 1063 uint64_t timeStamp = 1663869124160; 1064 uint32_t name = stream_.traceDataCache_->GetDataIndex("cpu_idle"); 1065 uint32_t cpu = 1; 1066 uint32_t internalTid = 1; 1067 1068 uint64_t timestamp1 = 1663869224160; 1069 uint32_t name1 = stream_.traceDataCache_->GetDataIndex("sched_waking"); 1070 uint32_t cpu1 = 2; 1071 uint32_t internalTid1 = 2; 1072 1073 stream_.traceDataCache_->GetRawData()->AppendRawData(timeStamp, name, cpu, internalTid); 1074 stream_.traceDataCache_->GetRawData()->AppendRawData(timestamp1, name1, cpu1, internalTid1); 1075 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 1076 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 1077 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 0); 1078 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 1); 1079 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect4, false), 1); 1080} 1081/** 1082 * @tc.name: SchedSliceTest 1083 * @tc.desc: Sched slice table test 1084 * @tc.type: FUNC 1085 */ 1086HWTEST_F(TableTest, SchedSliceTest, TestSize.Level1) 1087{ 1088 TS_LOGI("test31-35"); 1089 std::string sqlSelect = "select * from sched_slice"; 1090 std::string sqlSelect1 = "select * from sched_slice where id = 1"; 1091 std::string sqlSelect2 = "select * from sched_slice where ts > 1"; 1092 std::string sqlSelect3 = "select * from sched_slice where cpu < 1"; 1093 std::string sqlSelect4 = "select * from sched_slice where itid >= 1"; 1094 std::string sqlSelect5 = "select * from sched_slice where ipid <= 1"; 1095 std::string sqlSelect6 = "select * from sched_slice where dur >= 200"; 1096 uint64_t ts = 1663869124160; 1097 uint64_t dur = 200; 1098 uint64_t cpu = 1; 1099 uint64_t internalTid = 1; 1100 uint64_t endState = 1; 1101 uint64_t priority = 1; 1102 1103 uint64_t ts1 = 1663869224160; 1104 uint64_t dur1 = 200; 1105 uint64_t cpu1 = 2; 1106 uint64_t internalTid1 = 2; 1107 uint64_t endState1 = 2; 1108 uint64_t priority1 = 2; 1109 1110 SchedSliceRow schedSliceRow = {ts, dur, cpu, internalTid, endState, priority}; 1111 SchedSliceRow schedSliceRow1 = {ts1, dur1, cpu1, internalTid1, endState1, priority1}; 1112 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(schedSliceRow); 1113 stream_.traceDataCache_->GetSchedSliceData()->AppendSchedSlice(schedSliceRow1); 1114 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 2); 1115 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect1, false), 1); 1116 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect2, false), 2); 1117 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect3, false), 0); 1118 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect4, false), 2); 1119 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect5, false), 0); 1120 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect6, false), 2); 1121} 1122/** 1123 * @tc.name: SmapsTest 1124 * @tc.desc: Smaps table test 1125 * @tc.type: FUNC 1126 */ 1127HWTEST_F(TableTest, SmapsTest, TestSize.Level1) 1128{ 1129 TS_LOGI("test31-36"); 1130 std::string sqlSelect = "select * from smaps"; 1131 const uint64_t timeStamp = 1663869124160; 1132 const std::string startAddr = "startAddr"; 1133 const std::string endAddr = "endAddr"; 1134 const uint64_t size = 2; 1135 1136 SmapsRow row; 1137 row.timeStamp = timeStamp; 1138 row.ipid = IPID; 1139 row.startAddr = startAddr; 1140 row.endAddr = endAddr; 1141 row.dirty = 1; 1142 row.swapper = 1; 1143 row.rss = 1; 1144 row.pss = 1; 1145 row.size = size; 1146 row.reside = 1; 1147 row.protectionId = stream_.traceDataCache_->GetDataIndex("protection"); 1148 row.pathId = stream_.traceDataCache_->GetDataIndex("path"); 1149 row.sharedClean = 1; 1150 row.sharedDirty = 1; 1151 row.privateClean = 1; 1152 row.privateDirty = 1; 1153 row.swap = 1; 1154 row.swapPss = 1; 1155 row.type = 1; 1156 stream_.traceDataCache_->GetSmapsData()->AppendNewData(row); 1157 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 1); 1158} 1159/** 1160 * @tc.name: StatTableTest 1161 * @tc.desc: Stat table test 1162 * @tc.type: FUNC 1163 */ 1164HWTEST_F(TableTest, StatTableTest, TestSize.Level1) 1165{ 1166 TS_LOGI("test31-37"); 1167 std::string sqlSelect = "select * from stat"; 1168 stream_.traceDataCache_->GetStatAndInfo(); 1169 EXPECT_EQ(stream_.traceDataCache_->SearchDatabase(sqlSelect, false), 460); 1170} 1171/** 1172 * @tc.name: SymbolsTableTest 1173 * @tc.desc: Symbols table test 1174 * @tc.type: FUNC 1175 */ 1176HWTEST_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 */ 1199HWTEST_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 */ 1217HWTEST_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 */ 1248HWTEST_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 */ 1265HWTEST_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 */ 1277HWTEST_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 */ 1318HWTEST_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