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 #include "gpu_counter_object_table.h"
19 #include "gpu_counter_table.h"
20 #include "mock_plugin_result.pb.h"
21 #include "sdk_data_parser.h"
22 #include "slice_object_table.h"
23 #include "slice_table.h"
24 #include "ts_sdk_api.h"
25
26 using namespace testing::ext;
27 namespace SysTuning ::TraceStreamer {
28 class SDKApiTest : public ::testing::Test {
29 public:
SetUp()30 void SetUp()
31 {
32 stream_.InitFilter();
33 }
TearDown()34 void TearDown() {}
35
36 public:
37 TraceStreamerSelector stream_ = {};
38 DemoRpcServer *rpcServer = new DemoRpcServer();
39 };
40
41 std::string g_resultTest;
res(const std::string result,int32_t finish,int32_t isConfig)42 void res(const std::string result, int32_t finish, int32_t isConfig)
43 {
44 TS_LOGI("%s", result.c_str());
45 g_resultTest = result;
46 }
47
48 std::string g_reply;
QueryResultCallback(const std::string & jsonResult,int32_t finish,int32_t isConfig)49 void QueryResultCallback(const std::string &jsonResult, int32_t finish, int32_t isConfig)
50 {
51 g_reply = jsonResult;
52 }
53
54 /**
55 * @tc.name: SetTableName
56 * @tc.desc: Set the table name manually
57 * @tc.type: FUNC
58 */
59 HWTEST_F(SDKApiTest, SetTableName, TestSize.Level1)
60 {
61 TS_LOGI("test1-1");
62 SetRpcServer(rpcServer);
63 auto ret = SDKSetTableName("first_table", "second_table", "third_table", "fouth_table");
64 EXPECT_EQ(0, ret);
65 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
66 EXPECT_EQ(0, ret);
67 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
68 EXPECT_EQ(0, ret);
69 std::string sqlQueryCounter("select * from first_table;");
70 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
71 EXPECT_TRUE(ret);
72 EXPECT_EQ(g_resultTest.find("ok"), 0);
73
74 std::string sqlQueryCounterObj("select * from second_table;");
75 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
76 EXPECT_EQ(g_resultTest.find("ok"), 0);
77 EXPECT_TRUE(ret);
78 std::string sqlQuerySlice("select * from third_table;");
79 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
80 EXPECT_EQ(g_resultTest.find("ok"), 0);
81 EXPECT_TRUE(ret);
82 std::string sqlQuerySliceObj("select * from fouth_table;");
83 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
84 EXPECT_EQ(g_resultTest.find("ok"), 0);
85 EXPECT_TRUE(ret);
86 }
87
88 /**
89 * @tc.name: DefaultTableName
90 * @tc.desc: Use the default table name
91 * @tc.type: FUNC
92 */
93 HWTEST_F(SDKApiTest, DefaultTableName, TestSize.Level1)
94 {
95 TS_LOGI("test1-2");
96 SetRpcServer(rpcServer);
97 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
98 EXPECT_EQ(0, ret);
99 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
100 EXPECT_EQ(0, ret);
101 std::string sqlQueryCounter("select * from counter_table;");
102 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
103 EXPECT_EQ(g_resultTest.find("ok"), 0);
104 EXPECT_TRUE(ret);
105 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
106 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
107 EXPECT_EQ(g_resultTest.find("ok"), 0);
108 EXPECT_TRUE(ret);
109 std::string sqlQuerySlice("select * from slice_table;");
110 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
111 EXPECT_EQ(g_resultTest.find("ok"), 0);
112 EXPECT_TRUE(ret);
113 std::string sqlQuerySliceObj("select * from slice_object_table;");
114 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
115 EXPECT_EQ(g_resultTest.find("ok"), 0);
116 EXPECT_TRUE(ret);
117 }
118
119 /**
120 * @tc.name: NullTableName
121 * @tc.desc: Use the null table name
122 * @tc.type: FUNC
123 */
124 HWTEST_F(SDKApiTest, NullTableName, TestSize.Level1)
125 {
126 TS_LOGI("test1-3");
127 SetRpcServer(rpcServer);
128 auto ret = SDKSetTableName(" ", " ", " ", " ");
129 EXPECT_EQ(0, ret);
130 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
131 EXPECT_EQ(0, ret);
132 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
133 EXPECT_EQ(0, ret);
134 std::string sqlQueryCounter("select * from counter_table;");
135 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
136 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
137 EXPECT_FALSE(ret);
138 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
139 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
140 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
141 EXPECT_FALSE(ret);
142 std::string sqlQuerySlice("select * from slice_table;");
143 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
144 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
145 EXPECT_FALSE(ret);
146 std::string sqlQuerySliceObj("select * from slice_object_table;");
147 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
148 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
149 EXPECT_FALSE(ret);
150 }
151
152 /**
153 * @tc.name: NullAndManuallyCounterTableName
154 * @tc.desc: Use the null and manually counter table name
155 * @tc.type: FUNC
156 */
157 HWTEST_F(SDKApiTest, NullAndManuallyCounterTableName, TestSize.Level1)
158 {
159 TS_LOGI("test1-4");
160 SetRpcServer(rpcServer);
161 auto ret = SDKSetTableName("first_table", "second_table", " ", " ");
162 EXPECT_EQ(0, ret);
163 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
164 EXPECT_EQ(0, ret);
165 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
166 EXPECT_EQ(0, ret);
167 std::string sqlQueryCounter("select * from first_table;");
168 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
169 EXPECT_EQ(g_resultTest.find("ok"), 0);
170 EXPECT_TRUE(ret);
171 std::string sqlQueryCounterObj("select * from second_table;");
172 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
173 EXPECT_EQ(g_resultTest.find("ok"), 0);
174 EXPECT_TRUE(ret);
175 std::string sqlQuerySlice("select * from slice_table;");
176 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
177 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
178 EXPECT_FALSE(ret);
179 std::string sqlQuerySliceObj("select * from slice_object_table;");
180 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
181 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
182 EXPECT_FALSE(ret);
183 }
184
185 /**
186 * @tc.name: NullAndManuallySliceTableName
187 * @tc.desc: Use the null and manually slice table name
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SDKApiTest, NullAndManuallySliceTableName, TestSize.Level1)
191 {
192 TS_LOGI("test1-5");
193 SetRpcServer(rpcServer);
194 auto ret = SDKSetTableName(" ", " ", "first_table", "second_table");
195 EXPECT_EQ(0, ret);
196 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
197 EXPECT_EQ(0, ret);
198 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
199 EXPECT_EQ(0, ret);
200 std::string sqlQueryCounter("select * from counter_table;");
201 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
202 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
203 EXPECT_FALSE(ret);
204 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
205 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
206 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
207 EXPECT_FALSE(ret);
208 std::string sqlQuerySlice("select * from first_table;");
209 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
210 EXPECT_EQ(g_resultTest.find("ok"), 0);
211 EXPECT_TRUE(ret);
212 std::string sqlQuerySliceObj("select * from second_table;");
213 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
214 EXPECT_EQ(g_resultTest.find("ok"), 0);
215 EXPECT_TRUE(ret);
216 }
217
218 /**
219 * @tc.name: CurrentDataForCounterObjectWithDefaultTableName
220 * @tc.desc: Use CurrentData for CounterObject table with default table name
221 * @tc.type: FUNC
222 */
223 HWTEST_F(SDKApiTest, CurrentDataForCounterObjectWithDefaultTableName, TestSize.Level1)
224 {
225 TS_LOGI("test1-6");
226 SetRpcServer(rpcServer);
227 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
228 EXPECT_EQ(0, ret);
229 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
230 EXPECT_EQ(0, ret);
231 ret = SDKAppendCounterObject(1, "counter_1");
232 EXPECT_EQ(0, ret);
233 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
234 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
235 EXPECT_EQ(g_resultTest.find("ok"), 0);
236 EXPECT_TRUE(ret);
237 }
238
239 /**
240 * @tc.name: CurrentDataForCounterObjectWithManuallyTableName
241 * @tc.desc: Use CurrentData for CounterObject table with manually table name
242 * @tc.type: FUNC
243 */
244 HWTEST_F(SDKApiTest, CurrentDataForCounterObjectWithManuallyTableName, TestSize.Level1)
245 {
246 TS_LOGI("test1-7");
247 SetRpcServer(rpcServer);
248 auto ret = SDK_SetTableName(" ", "second_table", " ", " ");
249 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
250 EXPECT_EQ(0, ret);
251 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
252 EXPECT_EQ(0, ret);
253 ret = SDKAppendCounterObject(1, "counter_1");
254 EXPECT_EQ(0, ret);
255 std::string sqlQueryCounterObj("select * from second_table;");
256 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
257 EXPECT_EQ(g_resultTest.find("ok"), 0);
258 EXPECT_TRUE(ret);
259 }
260
261 /**
262 * @tc.name: WrongDataForCounterObjectWithDefaultTableName
263 * @tc.desc: Use WrongData for CounterObject table with default table name
264 * @tc.type: FUNC
265 */
266 HWTEST_F(SDKApiTest, WrongDataForCounterObjectWithDefaultTableName, TestSize.Level1)
267 {
268 TS_LOGI("test1-8");
269 SetRpcServer(rpcServer);
270 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
271 EXPECT_EQ(0, ret);
272 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
273 EXPECT_EQ(0, ret);
274 ret = SDKAppendCounterObject(INVALID_INT32, "counter_1");
275 EXPECT_EQ(0, ret);
276 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
277 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
278 EXPECT_EQ(g_resultTest.find("ok"), 0);
279 EXPECT_TRUE(ret);
280 }
281
282 /**
283 * @tc.name: WrongDataForCounterObjectWithManuallyTableName
284 * @tc.desc: Use WrongData for CounterObject table with manually table name
285 * @tc.type: FUNC
286 */
287 HWTEST_F(SDKApiTest, WrongDataForCounterObjectWithManuallyTableName, TestSize.Level1)
288 {
289 TS_LOGI("test1-9");
290 SetRpcServer(rpcServer);
291 auto ret = SDK_SetTableName(" ", "second_table", " ", " ");
292 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
293 EXPECT_EQ(0, ret);
294 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
295 EXPECT_EQ(0, ret);
296 ret = SDKAppendCounterObject(INVALID_INT32, "counter_1");
297 EXPECT_EQ(0, ret);
298 std::string sqlQueryCounterObj("select * from second_table;");
299 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
300 EXPECT_EQ(g_resultTest.find("ok"), 0);
301 EXPECT_TRUE(ret);
302 }
303
304 /**
305 * @tc.name: WrongDataForCounterObject
306 * @tc.desc: Use WrongData for CounterObject table
307 * @tc.type: FUNC
308 */
309 HWTEST_F(SDKApiTest, WrongDataForCounterObject, TestSize.Level1)
310 {
311 TS_LOGI("test1-10");
312 SetRpcServer(rpcServer);
313 auto ret = SDK_SetTableName(" ", "second_table", " ", " ");
314 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
315 EXPECT_EQ(0, ret);
316 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
317 EXPECT_EQ(0, ret);
318 ret = SDKAppendCounterObject(INVALID_INT32, " ");
319 EXPECT_EQ(0, ret);
320 std::string sqlQueryCounterObj("select * from gpu_counter_object;");
321 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounterObj.c_str(), sqlQueryCounterObj.length(), res);
322 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
323 EXPECT_FALSE(ret);
324 }
325
326 /**
327 * @tc.name: CurrentDataForCounterWithDefaultTableName
328 * @tc.desc: Use CurrentData for Counter table with default table name
329 * @tc.type: FUNC
330 */
331 HWTEST_F(SDKApiTest, CurrentDataForCounterWithDefaultTableName, TestSize.Level1)
332 {
333 TS_LOGI("test1-11");
334 SetRpcServer(rpcServer);
335 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
336 EXPECT_EQ(0, ret);
337 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
338 EXPECT_EQ(0, ret);
339 ret = SDKAppendCounter(1, 100, 100);
340 EXPECT_EQ(0, ret);
341 std::string sqlQueryCounter("select * from counter_table;");
342 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
343 EXPECT_EQ(g_resultTest.find("ok"), 0);
344 EXPECT_TRUE(ret);
345 }
346
347 /**
348 * @tc.name: CurrentDataForCounterWithManuallyTableName
349 * @tc.desc: Use CurrentData for Counter table with manually table name
350 * @tc.type: FUNC
351 */
352 HWTEST_F(SDKApiTest, CurrentDataForCounterWithManuallyTableName, TestSize.Level1)
353 {
354 TS_LOGI("test1-12");
355 SetRpcServer(rpcServer);
356 auto ret = SDK_SetTableName("first_table", " ", " ", " ");
357 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
358 EXPECT_EQ(0, ret);
359 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
360 EXPECT_EQ(0, ret);
361 ret = SDKAppendCounter(1, 100, 100);
362 EXPECT_EQ(0, ret);
363 std::string sqlQueryCounter("select * from first_table;");
364 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
365 EXPECT_EQ(g_resultTest.find("ok"), 0);
366 EXPECT_TRUE(ret);
367 }
368
369 /**
370 * @tc.name: WrongDataForCounterWithDefaultTableName
371 * @tc.desc: Use WrongData for Counter table with default table name
372 * @tc.type: FUNC
373 */
374 HWTEST_F(SDKApiTest, WrongDataForCounterWithDefaultTableName, TestSize.Level1)
375 {
376 TS_LOGI("test1-13");
377 SetRpcServer(rpcServer);
378 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
379 EXPECT_EQ(0, ret);
380 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
381 EXPECT_EQ(0, ret);
382 ret = SDKAppendCounter(INVALID_INT32, 100, 100);
383 EXPECT_EQ(0, ret);
384 std::string sqlQueryCounter("select * from counter_table;");
385 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
386 EXPECT_EQ(g_resultTest.find("ok"), 0);
387 EXPECT_TRUE(ret);
388 }
389
390 /**
391 * @tc.name: WrongDataForCounterWithManuallyTableName
392 * @tc.desc: Use WrongData for Counter table with manually table name
393 * @tc.type: FUNC
394 */
395 HWTEST_F(SDKApiTest, WrongDataForCounterWithManuallyTableName, TestSize.Level1)
396 {
397 TS_LOGI("test1-14");
398 SetRpcServer(rpcServer);
399 auto ret = SDK_SetTableName("first_table", " ", " ", " ");
400 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
401 EXPECT_EQ(0, ret);
402 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
403 EXPECT_EQ(0, ret);
404 ret = SDKAppendCounter(INVALID_INT32, 100, 100);
405 EXPECT_EQ(0, ret);
406 std::string sqlQueryCounter("select * from first_table;");
407 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
408 EXPECT_EQ(g_resultTest.find("ok"), 0);
409 EXPECT_TRUE(ret);
410 }
411
412 /**
413 * @tc.name: CounterWithWrongData
414 * @tc.desc: Use wrongData for counter table
415 * @tc.type: FUNC
416 */
417 HWTEST_F(SDKApiTest, CounterWithWrongData, TestSize.Level1)
418 {
419 TS_LOGI("test1-15");
420 SetRpcServer(rpcServer);
421 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
422 EXPECT_EQ(0, ret);
423 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
424 EXPECT_EQ(0, ret);
425 ret = SDKAppendCounter(INVALID_INT32, INVALID_UINT64, INVALID_INT32);
426 EXPECT_EQ(0, ret);
427 std::string sqlQueryCounter("select * from counter_table;");
428 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQueryCounter.c_str(), sqlQueryCounter.length(), res);
429 EXPECT_EQ(g_resultTest.find("ok"), 0);
430 EXPECT_TRUE(ret);
431 }
432
433 /**
434 * @tc.name: CurrentDataForSliceObjectWithDefaultTableName
435 * @tc.desc: Use CurrentData for SliceObject table with default table name
436 * @tc.type: FUNC
437 */
438 HWTEST_F(SDKApiTest, CurrentDataForSliceObjectWithDefaultTableName, TestSize.Level1)
439 {
440 TS_LOGI("test1-16");
441 SetRpcServer(rpcServer);
442 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
443 EXPECT_EQ(0, ret);
444 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
445 EXPECT_EQ(0, ret);
446 ret = SDKAppendSliceObject(1, "slice_1");
447 EXPECT_EQ(0, ret);
448 std::string sqlQuerySliceObj("select * from slice_object_table;");
449 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
450 EXPECT_EQ(g_resultTest.find("ok"), 0);
451 EXPECT_TRUE(ret);
452 }
453
454 /**
455 * @tc.name: CurrentDataForSliceObjectWithManuallyTableName
456 * @tc.desc: Use CurrentData for SliceObject table with manually table name
457 * @tc.type: FUNC
458 */
459 HWTEST_F(SDKApiTest, CurrentDataForSliceObjectWithManuallyTableName, TestSize.Level1)
460 {
461 TS_LOGI("test1-17");
462 SetRpcServer(rpcServer);
463 auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table");
464 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
465 EXPECT_EQ(0, ret);
466 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
467 EXPECT_EQ(0, ret);
468 ret = SDKAppendSliceObject(1, "slice_1");
469 EXPECT_EQ(0, ret);
470 std::string sqlQuerySliceObj("select * from fourth_table;");
471 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
472 EXPECT_EQ(g_resultTest.find("ok"), 0);
473 EXPECT_TRUE(ret);
474 }
475
476 /**
477 * @tc.name: WrongDataForSliceObjectWithDefaultTableName
478 * @tc.desc: Use WrongData for SliceObject table with default table name
479 * @tc.type: FUNC
480 */
481 HWTEST_F(SDKApiTest, WrongDataForSliceObjectWithDefaultTableName, TestSize.Level1)
482 {
483 TS_LOGI("test1-18");
484 SetRpcServer(rpcServer);
485 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
486 EXPECT_EQ(0, ret);
487 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
488 EXPECT_EQ(0, ret);
489 ret = SDKAppendSliceObject(1, "slice_1");
490 EXPECT_EQ(0, ret);
491 std::string sqlQuerySliceObj("select * from slice_object_table;");
492 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
493 EXPECT_EQ(g_resultTest.find("ok"), 0);
494 EXPECT_TRUE(ret);
495 }
496
497 /**
498 * @tc.name: WrongDataForSliceObjectWithManuallyTableName
499 * @tc.desc: Use WrongData for SliceObject table with manually table name
500 * @tc.type: FUNC
501 */
502 HWTEST_F(SDKApiTest, WrongDataForSliceObjectWithManuallyTableName, TestSize.Level1)
503 {
504 TS_LOGI("test1-19");
505 SetRpcServer(rpcServer);
506 auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table");
507 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
508 EXPECT_EQ(0, ret);
509 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
510 EXPECT_EQ(0, ret);
511 ret = SDKAppendSliceObject(INVALID_INT32, "slice_1");
512 EXPECT_EQ(0, ret);
513 std::string sqlQuerySliceObj("select * from slice_object_table;");
514 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
515 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
516 EXPECT_FALSE(ret);
517 }
518
519 /**
520 * @tc.name: WrongDataForSliceObject
521 * @tc.desc: Use WrongData for SliceObject table
522 * @tc.type: FUNC
523 */
524 HWTEST_F(SDKApiTest, WrongDataForSliceObject, TestSize.Level1)
525 {
526 TS_LOGI("test1-20");
527 SetRpcServer(rpcServer);
528 auto ret = SDK_SetTableName(" ", " ", " ", "fourth_table");
529 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
530 EXPECT_EQ(0, ret);
531 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
532 EXPECT_EQ(0, ret);
533 ret = SDKAppendSliceObject(INVALID_INT32, " ");
534 EXPECT_EQ(0, ret);
535 std::string sqlQuerySliceObj("select * from slice_object_table;");
536 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySliceObj.c_str(), sqlQuerySliceObj.length(), res);
537 EXPECT_EQ(g_resultTest.find("ok"), string::npos);
538 EXPECT_FALSE(ret);
539 }
540
541 /**
542 * @tc.name: CurrentDataForSliceWithDefaultTableName
543 * @tc.desc: Use CurrentData for Slice table with default table name
544 * @tc.type: FUNC
545 */
546 HWTEST_F(SDKApiTest, CurrentDataForSliceWithDefaultTableName, TestSize.Level1)
547 {
548 TS_LOGI("test1-21");
549 SetRpcServer(rpcServer);
550 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
551 EXPECT_EQ(0, ret);
552 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
553 EXPECT_EQ(0, ret);
554 ret = SDKAppendSlice(1, 100, 100, 100);
555 EXPECT_EQ(0, ret);
556 std::string sqlQuerySlice("select * from Slice_table;");
557 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
558 EXPECT_EQ(g_resultTest.find("ok"), 0);
559 EXPECT_TRUE(ret);
560 }
561
562 /**
563 * @tc.name: CurrentDataForSliceWithManuallyTableName
564 * @tc.desc: Use CurrentData for Slice table with manually table name
565 * @tc.type: FUNC
566 */
567 HWTEST_F(SDKApiTest, CurrentDataForSliceWithManuallyTableName, TestSize.Level1)
568 {
569 TS_LOGI("test1-22");
570 SetRpcServer(rpcServer);
571 auto ret = SDK_SetTableName(" ", " ", "third_table", " ");
572 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
573 EXPECT_EQ(0, ret);
574 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
575 EXPECT_EQ(0, ret);
576 ret = SDKAppendSlice(1, 100, 100, 100);
577 EXPECT_EQ(0, ret);
578 std::string sqlQuerySlice("select * from third_table;");
579 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
580 EXPECT_EQ(g_resultTest.find("ok"), 0);
581 EXPECT_TRUE(ret);
582 }
583
584 /**
585 * @tc.name: WrongDataForSliceWithDefaultTableName
586 * @tc.desc: Use WrongData for Slice table with default table name
587 * @tc.type: FUNC
588 */
589 HWTEST_F(SDKApiTest, WrongDataForSliceWithDefaultTableName, TestSize.Level1)
590 {
591 TS_LOGI("test1-23");
592 SetRpcServer(rpcServer);
593 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
594 EXPECT_EQ(0, ret);
595 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
596 EXPECT_EQ(0, ret);
597 ret = SDKAppendSlice(INVALID_INT32, 100, 100, 100);
598 EXPECT_EQ(0, ret);
599 std::string sqlQuerySlice("select * from Slice_table;");
600 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
601 EXPECT_EQ(g_resultTest.find("ok"), 0);
602 EXPECT_TRUE(ret);
603 }
604
605 /**
606 * @tc.name: WrongDataForSliceWithManuallyTableName
607 * @tc.desc: Use WrongData for Slice table with manually table name
608 * @tc.type: FUNC
609 */
610 HWTEST_F(SDKApiTest, WrongDataForSliceWithManuallyTableName, TestSize.Level1)
611 {
612 TS_LOGI("test1-24");
613 SetRpcServer(rpcServer);
614 auto ret = SDK_SetTableName(" ", " ", "third_table", " ");
615 ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
616 EXPECT_EQ(0, ret);
617 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
618 EXPECT_EQ(0, ret);
619 ret = SDKAppendSlice(INVALID_INT32, 100, 100, 100);
620 EXPECT_EQ(0, ret);
621 std::string sqlQuerySlice("select * from third_table;");
622 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
623 EXPECT_EQ(g_resultTest.find("ok"), 0);
624 EXPECT_TRUE(ret);
625 }
626
627 /**
628 * @tc.name: SliceWithWrongData
629 * @tc.desc: Use wrongData for slice table
630 * @tc.type: FUNC
631 */
632 HWTEST_F(SDKApiTest, SliceWithWrongData, TestSize.Level1)
633 {
634 TS_LOGI("test1-25");
635 SetRpcServer(rpcServer);
636 auto ret = rpcServer->demoTs_->sdkDataParser_->GetJsonConfig(QueryResultCallback);
637 EXPECT_EQ(0, ret);
638 ret = rpcServer->demoTs_->sdkDataParser_->CreateTableByJson();
639 EXPECT_EQ(0, ret);
640 ret = SDKAppendSlice(INVALID_INT32, INVALID_UINT64, INVALID_UINT64, INVALID_INT32);
641 EXPECT_EQ(0, ret);
642 std::string sqlQuerySlice("select * from slice_table;");
643 ret = rpcServer->DemoSqlQuery((const uint8_t *)sqlQuerySlice.c_str(), sqlQuerySlice.length(), res);
644 EXPECT_EQ(g_resultTest.find("ok"), 0);
645 EXPECT_TRUE(ret);
646 }
647 } // namespace SysTuning::TraceStreamer
648