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