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  */
HWTEST_F(TableTest, AppnameTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, ArgsTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, CallstackTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, ClkEventFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, ClockEventFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, CpuMeasureFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, CpuUsageFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, DataDictTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, DataTypeTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, DiskIoTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, EbpfCallstackTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, FileSystemSampleTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, HidumpTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, HisysEventMeasureTableTest, TestSize.Level1)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 = {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  */
HWTEST_F(TableTest, InstantTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, IoLatencySampleTableTest, TestSize.Level1)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     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  */
HWTEST_F(TableTest, IrqTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, LiveProcessTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, LogTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, MeasureTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, MeasureFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, MetaTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, NativeHookTableTest, TestSize.Level1)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     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  */
HWTEST_F(TableTest, NativeHookFrameTableTest, TestSize.Level1)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     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  */
HWTEST_F(TableTest, NetworkTableTest, TestSize.Level1)819 HWTEST_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  */
HWTEST_F(TableTest, PerfCallchainTableTest, TestSize.Level1)847 HWTEST_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  */
HWTEST_F(TableTest, PerfFilesTableTest, TestSize.Level1)883 HWTEST_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  */
HWTEST_F(TableTest, PerfReportTableTest, TestSize.Level1)910 HWTEST_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  */
HWTEST_F(TableTest, PerfSampleTableTest, TestSize.Level1)925 HWTEST_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  */
HWTEST_F(TableTest, PerfThreadTableTest, TestSize.Level1)970 HWTEST_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  */
HWTEST_F(TableTest, ProcessTableTest, TestSize.Level1)997 HWTEST_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  */
HWTEST_F(TableTest, ProcessMeasureTableTest, TestSize.Level1)1011 HWTEST_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  */
HWTEST_F(TableTest, ProcessMeasureFilterTableTest, TestSize.Level1)1028 HWTEST_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  */
HWTEST_F(TableTest, RawTableTest, TestSize.Level1)1055 HWTEST_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  */
HWTEST_F(TableTest, SchedSliceTest, TestSize.Level1)1086 HWTEST_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  */
HWTEST_F(TableTest, SmapsTest, TestSize.Level1)1127 HWTEST_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  */
HWTEST_F(TableTest, StatTableTest, TestSize.Level1)1164 HWTEST_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  */
HWTEST_F(TableTest, SymbolsTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, SyscallTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, SysEventFilterTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, SysMemMeasureTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, ThreadTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, ThreadStateTableTest, TestSize.Level1)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  */
HWTEST_F(TableTest, TraceRangeTableTest, TestSize.Level1)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