1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 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 "binder_filter.h" 20 #include "htrace_cpu_detail_parser.h" 21 #include "htrace_event_parser.h" 22 #include "trace_plugin_result.pb.h" 23 #include "trace_streamer_selector.h" 24 #include "ts_common.h" 25 26 using namespace testing::ext; 27 using namespace SysTuning::TraceStreamer; 28 namespace SysTuning { 29 namespace TraceStreamer { 30 class HtraceBinderEventTest : public ::testing::Test { 31 public: SetUp()32 void SetUp() 33 { 34 stream_.InitFilter(); 35 } 36 TearDown()37 void TearDown() {} 38 39 public: 40 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 41 }; 42 43 /** 44 * @tc.name: BinderSenderfilterNeedReply 45 * @tc.desc: Binary formate binder event test, The binder event needs reply 46 * @tc.type: FUNC 47 */ 48 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReply, TestSize.Level1) 49 { 50 TS_LOGI("test10-1"); 51 std::string appName = "app1"; 52 int64_t ts1 = 100; 53 uint32_t tid1 = 1; 54 uint64_t transactionId1 = 1; 55 int32_t destNode1 = 1; 56 int32_t destTgid1 = 2; 57 int32_t destTid1 = 3; 58 bool isReply = false; 59 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_); 0x01 60 uint32_t code = 0; // not important 61 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 62 binderEvent->set_to_proc(destTgid1); 63 binderEvent->set_target_node(destNode1); 64 binderEvent->set_to_thread(destTid1); 65 binderEvent->set_debug_id(transactionId1); 66 binderEvent->set_reply(static_cast<int32_t>(isReply)); 67 binderEvent->set_code(code); 68 binderEvent->set_flags(flags); 69 70 FtraceCpuDetailMsg ftraceCpuDetail; 71 ftraceCpuDetail.set_cpu(0); 72 ftraceCpuDetail.set_overwrite(0); 73 auto ftraceEvent = ftraceCpuDetail.add_event(); 74 75 ftraceEvent->set_timestamp(ts1); 76 ftraceEvent->set_tgid(tid1); 77 ftraceEvent->set_comm(appName); 78 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 79 80 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 81 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 82 eventParser.FilterAllEvents(); 83 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 84 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 85 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 86 } 87 88 /** 89 * @tc.name: BinderSenderfilterNeedReplyAndReceive 90 * @tc.desc: Binary formate binder event test, The binder event needs reply and received reply 91 * @tc.type: FUNC 92 */ 93 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceive, TestSize.Level1) 94 { 95 TS_LOGI("test10-2"); 96 std::string appName = "app1"; 97 int64_t ts1 = 100; 98 uint32_t tid1 = 1; 99 uint64_t transactionId1 = 1; 100 int32_t destNode1 = 1; 101 int32_t destTgid1 = 2; 102 int32_t destTid1 = 3; 103 bool isReply = false; 104 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_); 0x01 105 uint32_t code = 0; // not important 106 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 107 binderEvent->set_to_proc(destTgid1); 108 binderEvent->set_target_node(destNode1); 109 binderEvent->set_to_thread(destTid1); 110 binderEvent->set_debug_id(transactionId1); 111 binderEvent->set_reply(static_cast<int32_t>(isReply)); 112 binderEvent->set_code(code); 113 binderEvent->set_flags(flags); 114 115 FtraceCpuDetailMsg ftraceCpuDetail; 116 ftraceCpuDetail.set_cpu(0); 117 ftraceCpuDetail.set_overwrite(0); 118 auto ftraceEvent = ftraceCpuDetail.add_event(); 119 120 ftraceEvent->set_timestamp(ts1); 121 ftraceEvent->set_tgid(tid1); 122 ftraceEvent->set_comm(appName); 123 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 124 125 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 126 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 127 eventParser.FilterAllEvents(); 128 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 129 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 130 131 ts1 = 200; 132 uint32_t pid1 = 1; 133 FtraceCpuDetailMsg ftraceCpuDetail2; 134 ftraceCpuDetail2.set_cpu(0); 135 ftraceCpuDetail2.set_overwrite(0); 136 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 137 138 ftraceEvent2->set_timestamp(ts1); 139 ftraceEvent2->set_tgid(pid1); 140 std::string appName2 = "app2"; 141 ftraceEvent2->set_comm(appName2); 142 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 143 binderReceivedEvent->set_debug_id(transactionId1); 144 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 145 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 146 eventParser.FilterAllEvents(); 147 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 148 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 149 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1); 150 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 11); 151 } 152 153 /** 154 * @tc.name: BinderSenderfilterNeedReplyAndReceiveWithAlloc 155 * @tc.desc: Binary formate BinderTransactionAllocBuf event test, The binder event needs reply and received reply 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveWithAlloc, TestSize.Level1) 159 { 160 TS_LOGI("test10-3"); 161 int64_t ts1 = 100; 162 std::string appName = "app1"; 163 uint32_t tid1 = 1; 164 uint64_t transactionId1 = 1; 165 int32_t destNode1 = 1; 166 int32_t destTgid1 = 2; 167 int32_t destTid1 = 3; 168 bool isReply = false; 169 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 170 uint32_t code = 0; // not important 171 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 172 binderEvent->set_to_proc(destTgid1); 173 binderEvent->set_target_node(destNode1); 174 binderEvent->set_to_thread(destTid1); 175 binderEvent->set_debug_id(transactionId1); 176 binderEvent->set_reply(static_cast<int32_t>(isReply)); 177 binderEvent->set_code(code); 178 binderEvent->set_flags(flags); 179 180 FtraceCpuDetailMsg ftraceCpuDetail; 181 ftraceCpuDetail.set_cpu(0); 182 ftraceCpuDetail.set_overwrite(0); 183 auto ftraceEvent = ftraceCpuDetail.add_event(); 184 185 ftraceEvent->set_timestamp(ts1); 186 ftraceEvent->set_tgid(tid1); 187 ftraceEvent->set_comm(appName); 188 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 189 190 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 191 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 192 eventParser.FilterAllEvents(); 193 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 194 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 195 196 ts1 = 150; 197 uint64_t dataSize = 100; 198 uint64_t offsetSize = 200; 199 BinderTransactionAllocBufFormat* binderAllocEvent = new BinderTransactionAllocBufFormat(); 200 binderAllocEvent->set_data_size(dataSize); 201 binderAllocEvent->set_offsets_size(offsetSize); 202 203 FtraceCpuDetailMsg ftraceCpuDetail2; 204 ftraceCpuDetail2.set_cpu(0); 205 ftraceCpuDetail2.set_overwrite(0); 206 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 207 208 ftraceEvent2->set_timestamp(ts1); 209 ftraceEvent2->set_tgid(tid1); 210 ftraceEvent2->set_comm(appName); 211 ftraceEvent2->set_allocated_binder_transaction_alloc_buf_format(binderAllocEvent); 212 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 213 eventParser.FilterAllEvents(); 214 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 9); 215 216 ts1 = 200; 217 uint32_t pid1 = 1; 218 FtraceCpuDetailMsg ftraceCpuDetail3; 219 ftraceCpuDetail3.set_cpu(0); 220 ftraceCpuDetail3.set_overwrite(0); 221 auto ftraceEvent3 = ftraceCpuDetail3.add_event(); 222 223 ftraceEvent3->set_timestamp(ts1); 224 ftraceEvent3->set_tgid(pid1); 225 std::string appName2 = "app2"; 226 ftraceEvent3->set_comm(appName2); 227 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 228 binderReceivedEvent->set_debug_id(transactionId1); 229 ftraceEvent3->set_allocated_binder_transaction_received_format(binderReceivedEvent); 230 eventParser.ParseDataItem(&ftraceCpuDetail3, TS_CLOCK_BOOTTIME); 231 eventParser.FilterAllEvents(); 232 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 233 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 234 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1); 235 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 13); 236 } 237 238 /** 239 * @tc.name: BinderSenderfilterNeedReplyAndReceiveNotmatch 240 * @tc.desc: Binary formate BinderTransaction event test, The binder event needs reply but received not match 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveNotmatch, TestSize.Level1) 244 { 245 TS_LOGI("test10-4"); 246 std::string appName = "app1"; 247 int64_t ts1 = 100; 248 uint32_t tid1 = 1; 249 uint64_t transactionId1 = 1; 250 int32_t destNode1 = 1; 251 int32_t destTgid1 = 2; 252 int32_t destTid1 = 3; 253 bool isReply = false; 254 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 255 uint32_t code = 0; // not important 256 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 257 binderEvent->set_to_proc(destTgid1); 258 binderEvent->set_target_node(destNode1); 259 binderEvent->set_to_thread(destTid1); 260 binderEvent->set_debug_id(transactionId1); 261 binderEvent->set_reply(static_cast<int32_t>(isReply)); 262 binderEvent->set_code(code); 263 binderEvent->set_flags(flags); 264 265 FtraceCpuDetailMsg ftraceCpuDetail; 266 ftraceCpuDetail.set_cpu(0); 267 ftraceCpuDetail.set_overwrite(0); 268 auto ftraceEvent = ftraceCpuDetail.add_event(); 269 270 ftraceEvent->set_timestamp(ts1); 271 ftraceEvent->set_tgid(tid1); 272 ftraceEvent->set_comm(appName); 273 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 274 275 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 276 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 277 eventParser.FilterAllEvents(); 278 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 279 280 ts1 = 200; 281 uint32_t pid1 = 1; 282 uint64_t transactionId2 = 2; 283 FtraceCpuDetailMsg ftraceCpuDetail2; 284 ftraceCpuDetail2.set_cpu(0); 285 ftraceCpuDetail2.set_overwrite(0); 286 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 287 288 ftraceEvent2->set_timestamp(ts1); 289 ftraceEvent2->set_tgid(pid1); 290 std::string appName2 = "app2"; 291 ftraceEvent2->set_comm(appName2); 292 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 293 binderReceivedEvent->set_debug_id(transactionId2); 294 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 295 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 296 eventParser.FilterAllEvents(); 297 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 298 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 299 } 300 301 /** 302 * @tc.name: BinderSenderfilterNoNeedReply 303 * @tc.desc: Binary formate binder event test, The binder event needs no reply 304 * @tc.type: FUNC 305 */ 306 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNoNeedReply, TestSize.Level1) 307 { 308 TS_LOGI("test10-5"); 309 std::string appName = "app1"; 310 int64_t ts1 = 100; 311 uint32_t tid1 = 1; 312 uint64_t transactionId1 = 1; 313 int32_t destNode1 = 1; 314 int32_t destTgid1 = 2; 315 int32_t destTid1 = 3; 316 bool isReply = false; 317 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 318 uint32_t code = 0; // not important 319 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 320 binderEvent->set_to_proc(destTgid1); 321 binderEvent->set_target_node(destNode1); 322 binderEvent->set_to_thread(destTid1); 323 binderEvent->set_debug_id(transactionId1); 324 binderEvent->set_reply(static_cast<int32_t>(isReply)); 325 binderEvent->set_code(code); 326 binderEvent->set_flags(flags); 327 328 FtraceCpuDetailMsg ftraceCpuDetail; 329 ftraceCpuDetail.set_cpu(0); 330 ftraceCpuDetail.set_overwrite(0); 331 auto ftraceEvent = ftraceCpuDetail.add_event(); 332 333 ftraceEvent->set_timestamp(ts1); 334 ftraceEvent->set_tgid(tid1); 335 ftraceEvent->set_comm(appName); 336 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 337 338 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 339 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 340 eventParser.FilterAllEvents(); 341 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 342 } 343 344 /** 345 * @tc.name: BinderSenderNoneedReplyAndReceivefilter 346 * @tc.desc: Binary formate binder event test, other party received and no need reply。 347 * @tc.type: FUNC 348 */ 349 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilter, TestSize.Level1) 350 { 351 TS_LOGI("test10-6"); 352 std::string appName = "app1"; 353 int64_t ts1 = 100; 354 uint32_t tid1 = 1; 355 uint64_t transactionId1 = 1; 356 int32_t destNode1 = 1; 357 int32_t destTgid1 = 2; 358 int32_t destTid1 = 3; 359 bool isReply = false; 360 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 361 uint32_t code = 0; // not important 362 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 363 binderEvent->set_to_proc(destTgid1); 364 binderEvent->set_target_node(destNode1); 365 binderEvent->set_to_thread(destTid1); 366 binderEvent->set_debug_id(transactionId1); 367 binderEvent->set_reply(static_cast<int32_t>(isReply)); 368 binderEvent->set_code(code); 369 binderEvent->set_flags(flags); 370 371 FtraceCpuDetailMsg ftraceCpuDetail; 372 ftraceCpuDetail.set_cpu(0); 373 ftraceCpuDetail.set_overwrite(0); 374 auto ftraceEvent = ftraceCpuDetail.add_event(); 375 376 ftraceEvent->set_timestamp(ts1); 377 ftraceEvent->set_tgid(tid1); 378 ftraceEvent->set_comm(appName); 379 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 380 381 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 382 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 383 eventParser.FilterAllEvents(); 384 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 385 386 ts1 = 200; 387 uint32_t pid1 = 1; 388 FtraceCpuDetailMsg ftraceCpuDetail2; 389 ftraceCpuDetail2.set_cpu(0); 390 ftraceCpuDetail2.set_overwrite(0); 391 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 392 393 ftraceEvent2->set_timestamp(ts1); 394 ftraceEvent2->set_tgid(pid1); 395 std::string appName2 = "app2"; 396 ftraceEvent2->set_comm(appName2); 397 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 398 binderReceivedEvent->set_debug_id(transactionId1); 399 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 400 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 401 eventParser.FilterAllEvents(); 402 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 403 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 404 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 0); 405 } 406 407 /** 408 * @tc.name: BinderSenderNoneedReplyAndReceivefilterNotmatch 409 * @tc.desc: Binary formate binder event test, other party received but not match 410 * @tc.type: FUNC 411 */ 412 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilterNotmatch, TestSize.Level1) 413 { 414 TS_LOGI("test10-7"); 415 std::string appName = "app1"; 416 int64_t ts1 = 100; 417 uint32_t tid1 = 1; 418 uint64_t transactionId1 = 1; 419 int32_t destNode1 = 1; 420 int32_t destTgid1 = 2; 421 int32_t destTid1 = 3; 422 bool isReply = false; 423 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 424 uint32_t code = 0; // not importent 425 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 426 binderEvent->set_to_proc(destTgid1); 427 binderEvent->set_target_node(destNode1); 428 binderEvent->set_to_thread(destTid1); 429 binderEvent->set_debug_id(transactionId1); 430 binderEvent->set_reply(static_cast<int32_t>(isReply)); 431 binderEvent->set_code(code); 432 binderEvent->set_flags(flags); 433 434 FtraceCpuDetailMsg ftraceCpuDetail; 435 ftraceCpuDetail.set_cpu(0); 436 ftraceCpuDetail.set_overwrite(0); 437 auto ftraceEvent = ftraceCpuDetail.add_event(); 438 439 ftraceEvent->set_timestamp(ts1); 440 ftraceEvent->set_tgid(tid1); 441 ftraceEvent->set_comm(appName); 442 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 443 444 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 445 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 446 eventParser.FilterAllEvents(); 447 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 448 449 ts1 = 200; 450 uint32_t pid1 = 1; 451 uint64_t transactionId2 = 2; 452 FtraceCpuDetailMsg ftraceCpuDetail2; 453 ftraceCpuDetail2.set_cpu(0); 454 ftraceCpuDetail2.set_overwrite(0); 455 auto ftraceEvent2 = ftraceCpuDetail2.add_event(); 456 457 ftraceEvent2->set_timestamp(ts1); 458 ftraceEvent2->set_tgid(pid1); 459 std::string appName2 = "app2"; 460 ftraceEvent2->set_comm(appName2); 461 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 462 binderReceivedEvent->set_debug_id(transactionId2); 463 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 464 eventParser.ParseDataItem(&ftraceCpuDetail2, TS_CLOCK_BOOTTIME); 465 eventParser.FilterAllEvents(); 466 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 467 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 468 } 469 470 /** 471 * @tc.name: BinderSenderfilterWrongReply 472 * @tc.desc: Binary formate binder event test, other party replyed wrong Info 473 * @tc.type: FUNC 474 */ 475 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterWrongReply, TestSize.Level1) 476 { 477 TS_LOGI("test10-8"); 478 std::string appName = "app1"; 479 int64_t ts1 = 100; 480 uint32_t tid1 = 1; 481 uint64_t transactionId1 = 1; 482 int32_t destNode1 = 1; 483 int32_t destTgid1 = 2; 484 int32_t destTid1 = 3; 485 bool isReply = true; 486 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 487 uint32_t code = 0; // not important 488 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 489 binderEvent->set_to_proc(destTgid1); 490 binderEvent->set_target_node(destNode1); 491 binderEvent->set_to_thread(destTid1); 492 binderEvent->set_debug_id(transactionId1); 493 binderEvent->set_reply(static_cast<int32_t>(isReply)); 494 binderEvent->set_code(code); 495 binderEvent->set_flags(flags); 496 497 FtraceCpuDetailMsg ftraceCpuDetail; 498 ftraceCpuDetail.set_cpu(0); 499 ftraceCpuDetail.set_overwrite(0); 500 auto ftraceEvent = ftraceCpuDetail.add_event(); 501 502 ftraceEvent->set_timestamp(ts1); 503 ftraceEvent->set_tgid(tid1); 504 ftraceEvent->set_comm(appName); 505 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 506 507 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 508 eventParser.ParseDataItem(&ftraceCpuDetail, TS_CLOCK_BOOTTIME); 509 eventParser.FilterAllEvents(); 510 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 0); 511 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 0); 512 } 513 } // namespace TraceStreamer 514 } // namespace SysTuning 515