1 //===-- GDBRemoteCommunicationClientTest.cpp --------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 #include <future> 10 11 #include "GDBRemoteTestUtils.h" 12 13 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h" 14 #include "lldb/Core/ModuleSpec.h" 15 #include "lldb/Core/StructuredData.h" 16 #include "lldb/Core/TraceOptions.h" 17 #include "lldb/Target/MemoryRegionInfo.h" 18 #include "lldb/Utility/DataBuffer.h" 19 20 #include "llvm/ADT/ArrayRef.h" 21 22 using namespace lldb_private::process_gdb_remote; 23 using namespace lldb_private; 24 using namespace lldb; 25 using namespace llvm; 26 27 namespace { 28 29 typedef GDBRemoteCommunication::PacketResult PacketResult; 30 31 struct TestClient : public GDBRemoteCommunicationClient { 32 TestClient() { m_send_acks = false; } 33 }; 34 35 void Handle_QThreadSuffixSupported(MockServer &server, bool supported) { 36 StringExtractorGDBRemote request; 37 ASSERT_EQ(PacketResult::Success, server.GetPacket(request)); 38 ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef()); 39 if (supported) 40 ASSERT_EQ(PacketResult::Success, server.SendOKResponse()); 41 else 42 ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr)); 43 } 44 45 void HandlePacket(MockServer &server, StringRef expected, StringRef response) { 46 StringExtractorGDBRemote request; 47 ASSERT_EQ(PacketResult::Success, server.GetPacket(request)); 48 ASSERT_EQ(expected, request.GetStringRef()); 49 ASSERT_EQ(PacketResult::Success, server.SendPacket(response)); 50 } 51 52 uint8_t all_registers[] = {'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 53 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'}; 54 std::string all_registers_hex = "404142434445464748494a4b4c4d4e4f"; 55 uint8_t one_register[] = {'A', 'B', 'C', 'D'}; 56 std::string one_register_hex = "41424344"; 57 58 } // end anonymous namespace 59 60 class GDBRemoteCommunicationClientTest : public GDBRemoteTest {}; 61 62 TEST_F(GDBRemoteCommunicationClientTest, WriteRegister) { 63 TestClient client; 64 MockServer server; 65 Connect(client, server); 66 if (HasFailure()) 67 return; 68 69 const lldb::tid_t tid = 0x47; 70 const uint32_t reg_num = 4; 71 std::future<bool> write_result = std::async(std::launch::async, [&] { 72 return client.WriteRegister(tid, reg_num, one_register); 73 }); 74 75 Handle_QThreadSuffixSupported(server, true); 76 77 HandlePacket(server, "P4=" + one_register_hex + ";thread:0047;", "OK"); 78 ASSERT_TRUE(write_result.get()); 79 80 write_result = std::async(std::launch::async, [&] { 81 return client.WriteAllRegisters(tid, all_registers); 82 }); 83 84 HandlePacket(server, "G" + all_registers_hex + ";thread:0047;", "OK"); 85 ASSERT_TRUE(write_result.get()); 86 } 87 88 TEST_F(GDBRemoteCommunicationClientTest, WriteRegisterNoSuffix) { 89 TestClient client; 90 MockServer server; 91 Connect(client, server); 92 if (HasFailure()) 93 return; 94 95 const lldb::tid_t tid = 0x47; 96 const uint32_t reg_num = 4; 97 std::future<bool> write_result = std::async(std::launch::async, [&] { 98 return client.WriteRegister(tid, reg_num, one_register); 99 }); 100 101 Handle_QThreadSuffixSupported(server, false); 102 HandlePacket(server, "Hg47", "OK"); 103 HandlePacket(server, "P4=" + one_register_hex, "OK"); 104 ASSERT_TRUE(write_result.get()); 105 106 write_result = std::async(std::launch::async, [&] { 107 return client.WriteAllRegisters(tid, all_registers); 108 }); 109 110 HandlePacket(server, "G" + all_registers_hex, "OK"); 111 ASSERT_TRUE(write_result.get()); 112 } 113 114 TEST_F(GDBRemoteCommunicationClientTest, ReadRegister) { 115 TestClient client; 116 MockServer server; 117 Connect(client, server); 118 if (HasFailure()) 119 return; 120 121 const lldb::tid_t tid = 0x47; 122 const uint32_t reg_num = 4; 123 std::future<bool> async_result = std::async( 124 std::launch::async, [&] { return client.GetpPacketSupported(tid); }); 125 Handle_QThreadSuffixSupported(server, true); 126 HandlePacket(server, "p0;thread:0047;", one_register_hex); 127 ASSERT_TRUE(async_result.get()); 128 129 std::future<DataBufferSP> read_result = std::async( 130 std::launch::async, [&] { return client.ReadRegister(tid, reg_num); }); 131 HandlePacket(server, "p4;thread:0047;", "41424344"); 132 auto buffer_sp = read_result.get(); 133 ASSERT_TRUE(bool(buffer_sp)); 134 ASSERT_EQ(0, 135 memcmp(buffer_sp->GetBytes(), one_register, sizeof one_register)); 136 137 read_result = std::async(std::launch::async, 138 [&] { return client.ReadAllRegisters(tid); }); 139 HandlePacket(server, "g;thread:0047;", all_registers_hex); 140 buffer_sp = read_result.get(); 141 ASSERT_TRUE(bool(buffer_sp)); 142 ASSERT_EQ(0, 143 memcmp(buffer_sp->GetBytes(), all_registers, sizeof all_registers)); 144 } 145 146 TEST_F(GDBRemoteCommunicationClientTest, SaveRestoreRegistersNoSuffix) { 147 TestClient client; 148 MockServer server; 149 Connect(client, server); 150 if (HasFailure()) 151 return; 152 153 const lldb::tid_t tid = 0x47; 154 uint32_t save_id; 155 std::future<bool> async_result = std::async(std::launch::async, [&] { 156 return client.SaveRegisterState(tid, save_id); 157 }); 158 Handle_QThreadSuffixSupported(server, false); 159 HandlePacket(server, "Hg47", "OK"); 160 HandlePacket(server, "QSaveRegisterState", "1"); 161 ASSERT_TRUE(async_result.get()); 162 EXPECT_EQ(1u, save_id); 163 164 async_result = std::async(std::launch::async, [&] { 165 return client.RestoreRegisterState(tid, save_id); 166 }); 167 HandlePacket(server, "QRestoreRegisterState:1", "OK"); 168 ASSERT_TRUE(async_result.get()); 169 } 170 171 TEST_F(GDBRemoteCommunicationClientTest, SyncThreadState) { 172 TestClient client; 173 MockServer server; 174 Connect(client, server); 175 if (HasFailure()) 176 return; 177 178 const lldb::tid_t tid = 0x47; 179 std::future<bool> async_result = std::async( 180 std::launch::async, [&] { return client.SyncThreadState(tid); }); 181 HandlePacket(server, "qSyncThreadStateSupported", "OK"); 182 HandlePacket(server, "QSyncThreadState:0047;", "OK"); 183 ASSERT_TRUE(async_result.get()); 184 } 185 186 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo) { 187 TestClient client; 188 MockServer server; 189 Connect(client, server); 190 if (HasFailure()) 191 return; 192 193 llvm::Triple triple("i386-pc-linux"); 194 195 FileSpec file_specs[] = { 196 FileSpec("/foo/bar.so", false, FileSpec::ePathSyntaxPosix), 197 FileSpec("/foo/baz.so", false, FileSpec::ePathSyntaxPosix), 198 199 // This is a bit dodgy but we currently depend on GetModulesInfo not 200 // performing denormalization. It can go away once the users 201 // (DynamicLoaderPOSIXDYLD, at least) correctly set the path syntax for 202 // the FileSpecs they create. 203 FileSpec("/foo/baw.so", false, FileSpec::ePathSyntaxWindows), 204 }; 205 std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result = 206 std::async(std::launch::async, 207 [&] { return client.GetModulesInfo(file_specs, triple); }); 208 HandlePacket( 209 server, "jModulesInfo:[" 210 R"({"file":"/foo/bar.so","triple":"i386-pc-linux"},)" 211 R"({"file":"/foo/baz.so","triple":"i386-pc-linux"},)" 212 R"({"file":"/foo/baw.so","triple":"i386-pc-linux"}])", 213 R"([{"uuid":"404142434445464748494a4b4c4d4e4f","triple":"i386-pc-linux",)" 214 R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])"); 215 216 auto result = async_result.get(); 217 ASSERT_TRUE(result.hasValue()); 218 ASSERT_EQ(1u, result->size()); 219 EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath()); 220 EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple()); 221 EXPECT_EQ(UUID("@ABCDEFGHIJKLMNO", 16), result.getValue()[0].GetUUID()); 222 EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset()); 223 EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize()); 224 } 225 226 TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfoInvalidResponse) { 227 TestClient client; 228 MockServer server; 229 Connect(client, server); 230 if (HasFailure()) 231 return; 232 233 llvm::Triple triple("i386-pc-linux"); 234 FileSpec file_spec("/foo/bar.so", false, FileSpec::ePathSyntaxPosix); 235 236 const char *invalid_responses[] = { 237 "OK", "E47", "[]", 238 // no UUID 239 R"([{"triple":"i386-pc-linux",)" 240 R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}])", 241 // no triple 242 R"([{"uuid":"404142434445464748494a4b4c4d4e4f",)" 243 R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}])", 244 // no file_path 245 R"([{"uuid":"404142434445464748494a4b4c4d4e4f","triple":"i386-pc-linux",)" 246 R"("file_offset":0,"file_size":1234}])", 247 // no file_offset 248 R"([{"uuid":"404142434445464748494a4b4c4d4e4f","triple":"i386-pc-linux",)" 249 R"("file_path":"/foo/bar.so","file_size":1234}])", 250 // no file_size 251 R"([{"uuid":"404142434445464748494a4b4c4d4e4f","triple":"i386-pc-linux",)" 252 R"("file_path":"/foo/bar.so","file_offset":0}])", 253 }; 254 255 for (const char *response : invalid_responses) { 256 std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result = 257 std::async(std::launch::async, 258 [&] { return client.GetModulesInfo(file_spec, triple); }); 259 HandlePacket( 260 server, 261 R"(jModulesInfo:[{"file":"/foo/bar.so","triple":"i386-pc-linux"}])", 262 response); 263 264 ASSERT_FALSE(async_result.get().hasValue()) << "response was: " << response; 265 } 266 } 267 268 TEST_F(GDBRemoteCommunicationClientTest, TestPacketSpeedJSON) { 269 TestClient client; 270 MockServer server; 271 Connect(client, server); 272 if (HasFailure()) 273 return; 274 275 std::thread server_thread([&server] { 276 for (;;) { 277 StringExtractorGDBRemote request; 278 PacketResult result = server.GetPacket(request); 279 if (result == PacketResult::ErrorDisconnected) 280 return; 281 ASSERT_EQ(PacketResult::Success, result); 282 StringRef ref = request.GetStringRef(); 283 ASSERT_TRUE(ref.consume_front("qSpeedTest:response_size:")); 284 int size; 285 ASSERT_FALSE(ref.consumeInteger(10, size)) << "ref: " << ref; 286 std::string response(size, 'X'); 287 ASSERT_EQ(PacketResult::Success, server.SendPacket(response)); 288 } 289 }); 290 291 StreamString ss; 292 client.TestPacketSpeed(10, 32, 32, 4096, true, ss); 293 client.Disconnect(); 294 server_thread.join(); 295 296 GTEST_LOG_(INFO) << "Formatted output: " << ss.GetData(); 297 auto object_sp = StructuredData::ParseJSON(ss.GetString()); 298 ASSERT_TRUE(bool(object_sp)); 299 auto dict_sp = object_sp->GetAsDictionary(); 300 ASSERT_TRUE(bool(dict_sp)); 301 302 object_sp = dict_sp->GetValueForKey("packet_speeds"); 303 ASSERT_TRUE(bool(object_sp)); 304 dict_sp = object_sp->GetAsDictionary(); 305 ASSERT_TRUE(bool(dict_sp)); 306 307 int num_packets; 308 ASSERT_TRUE(dict_sp->GetValueForKeyAsInteger("num_packets", num_packets)) 309 << ss.GetString(); 310 ASSERT_EQ(10, num_packets); 311 } 312 313 TEST_F(GDBRemoteCommunicationClientTest, SendSignalsToIgnore) { 314 TestClient client; 315 MockServer server; 316 Connect(client, server); 317 if (HasFailure()) 318 return; 319 320 const lldb::tid_t tid = 0x47; 321 const uint32_t reg_num = 4; 322 std::future<Status> result = std::async(std::launch::async, [&] { 323 return client.SendSignalsToIgnore({2, 3, 5, 7, 0xB, 0xD, 0x11}); 324 }); 325 326 HandlePacket(server, "QPassSignals:02;03;05;07;0b;0d;11", "OK"); 327 EXPECT_TRUE(result.get().Success()); 328 329 result = std::async(std::launch::async, [&] { 330 return client.SendSignalsToIgnore(std::vector<int32_t>()); 331 }); 332 333 HandlePacket(server, "QPassSignals:", "OK"); 334 EXPECT_TRUE(result.get().Success()); 335 } 336 337 TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfo) { 338 TestClient client; 339 MockServer server; 340 Connect(client, server); 341 if (HasFailure()) 342 return; 343 344 const lldb::addr_t addr = 0xa000; 345 MemoryRegionInfo region_info; 346 std::future<Status> result = std::async(std::launch::async, [&] { 347 return client.GetMemoryRegionInfo(addr, region_info); 348 }); 349 350 // name is: /foo/bar.so 351 HandlePacket(server, 352 "qMemoryRegionInfo:a000", 353 "start:a000;size:2000;permissions:rx;name:2f666f6f2f6261722e736f;"); 354 EXPECT_TRUE(result.get().Success()); 355 356 } 357 358 TEST_F(GDBRemoteCommunicationClientTest, GetMemoryRegionInfoInvalidResponse) { 359 TestClient client; 360 MockServer server; 361 Connect(client, server); 362 if (HasFailure()) 363 return; 364 365 const lldb::addr_t addr = 0x4000; 366 MemoryRegionInfo region_info; 367 std::future<Status> result = std::async(std::launch::async, [&] { 368 return client.GetMemoryRegionInfo(addr, region_info); 369 }); 370 371 HandlePacket(server, "qMemoryRegionInfo:4000", "start:4000;size:0000;"); 372 EXPECT_FALSE(result.get().Success()); 373 } 374 375 TEST_F(GDBRemoteCommunicationClientTest, SendStartTracePacket) { 376 TestClient client; 377 MockServer server; 378 Connect(client, server); 379 if (HasFailure()) 380 return; 381 382 TraceOptions options; 383 Status error; 384 385 options.setType(lldb::TraceType::eTraceTypeProcessorTrace); 386 options.setMetaDataBufferSize(8192); 387 options.setTraceBufferSize(8192); 388 options.setThreadID(0x23); 389 390 StructuredData::DictionarySP custom_params = 391 std::make_shared<StructuredData::Dictionary>(); 392 custom_params->AddStringItem("tracetech", "intel-pt"); 393 custom_params->AddIntegerItem("psb", 0x01); 394 395 options.setTraceParams(custom_params); 396 397 std::future<lldb::user_id_t> result = std::async(std::launch::async, [&] { 398 return client.SendStartTracePacket(options, error); 399 }); 400 401 // Since the line is exceeding 80 characters. 402 std::string expected_packet1 = 403 R"(jTraceStart:{"buffersize" : 8192,"metabuffersize" : 8192,"params" :)"; 404 std::string expected_packet2 = 405 R"( {"psb" : 1,"tracetech" : "intel-pt"},"threadid" : 35,"type" : 1})"; 406 HandlePacket(server, (expected_packet1 + expected_packet2), "1"); 407 ASSERT_TRUE(error.Success()); 408 ASSERT_EQ(result.get(), 1); 409 410 error.Clear(); 411 result = std::async(std::launch::async, [&] { 412 return client.SendStartTracePacket(options, error); 413 }); 414 415 HandlePacket(server, (expected_packet1 + expected_packet2), "E23"); 416 ASSERT_EQ(result.get(), LLDB_INVALID_UID); 417 ASSERT_FALSE(error.Success()); 418 } 419 420 TEST_F(GDBRemoteCommunicationClientTest, SendStopTracePacket) { 421 TestClient client; 422 MockServer server; 423 Connect(client, server); 424 if (HasFailure()) 425 return; 426 427 lldb::tid_t thread_id = 0x23; 428 lldb::user_id_t trace_id = 3; 429 430 std::future<Status> result = std::async(std::launch::async, [&] { 431 return client.SendStopTracePacket(trace_id, thread_id); 432 }); 433 434 const char *expected_packet = 435 R"(jTraceStop:{"threadid" : 35,"traceid" : 3})"; 436 HandlePacket(server, expected_packet, "OK"); 437 ASSERT_TRUE(result.get().Success()); 438 439 result = std::async(std::launch::async, [&] { 440 return client.SendStopTracePacket(trace_id, thread_id); 441 }); 442 443 HandlePacket(server, expected_packet, "E23"); 444 ASSERT_FALSE(result.get().Success()); 445 } 446 447 TEST_F(GDBRemoteCommunicationClientTest, SendGetDataPacket) { 448 TestClient client; 449 MockServer server; 450 Connect(client, server); 451 if (HasFailure()) 452 return; 453 454 lldb::tid_t thread_id = 0x23; 455 lldb::user_id_t trace_id = 3; 456 457 uint8_t buf[32] = {}; 458 llvm::MutableArrayRef<uint8_t> buffer(buf, 32); 459 size_t offset = 0; 460 461 std::future<Status> result = std::async(std::launch::async, [&] { 462 return client.SendGetDataPacket(trace_id, thread_id, buffer, offset); 463 }); 464 465 std::string expected_packet1 = 466 R"(jTraceBufferRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,)"; 467 std::string expected_packet2 = R"("traceid" : 3})"; 468 HandlePacket(server, expected_packet1+expected_packet2, "123456"); 469 ASSERT_TRUE(result.get().Success()); 470 ASSERT_EQ(buffer.size(), 3); 471 ASSERT_EQ(buf[0], 0x12); 472 ASSERT_EQ(buf[1], 0x34); 473 ASSERT_EQ(buf[2], 0x56); 474 475 llvm::MutableArrayRef<uint8_t> buffer2(buf, 32); 476 result = std::async(std::launch::async, [&] { 477 return client.SendGetDataPacket(trace_id, thread_id, buffer2, offset); 478 }); 479 480 HandlePacket(server, expected_packet1+expected_packet2, "E23"); 481 ASSERT_FALSE(result.get().Success()); 482 ASSERT_EQ(buffer2.size(), 0); 483 } 484 485 TEST_F(GDBRemoteCommunicationClientTest, SendGetMetaDataPacket) { 486 TestClient client; 487 MockServer server; 488 Connect(client, server); 489 if (HasFailure()) 490 return; 491 492 lldb::tid_t thread_id = 0x23; 493 lldb::user_id_t trace_id = 3; 494 495 uint8_t buf[32] = {}; 496 llvm::MutableArrayRef<uint8_t> buffer(buf, 32); 497 size_t offset = 0; 498 499 std::future<Status> result = std::async(std::launch::async, [&] { 500 return client.SendGetMetaDataPacket(trace_id, thread_id, buffer, offset); 501 }); 502 503 std::string expected_packet1 = 504 R"(jTraceMetaRead:{"buffersize" : 32,"offset" : 0,"threadid" : 35,)"; 505 std::string expected_packet2 = R"("traceid" : 3})"; 506 HandlePacket(server, expected_packet1+expected_packet2, "123456"); 507 ASSERT_TRUE(result.get().Success()); 508 ASSERT_EQ(buffer.size(), 3); 509 ASSERT_EQ(buf[0], 0x12); 510 ASSERT_EQ(buf[1], 0x34); 511 ASSERT_EQ(buf[2], 0x56); 512 513 llvm::MutableArrayRef<uint8_t> buffer2(buf, 32); 514 result = std::async(std::launch::async, [&] { 515 return client.SendGetMetaDataPacket(trace_id, thread_id, buffer2, offset); 516 }); 517 518 HandlePacket(server, expected_packet1+expected_packet2, "E23"); 519 ASSERT_FALSE(result.get().Success()); 520 ASSERT_EQ(buffer2.size(), 0); 521 } 522 523 TEST_F(GDBRemoteCommunicationClientTest, SendGetTraceConfigPacket) { 524 TestClient client; 525 MockServer server; 526 Connect(client, server); 527 if (HasFailure()) 528 return; 529 530 lldb::tid_t thread_id = 0x23; 531 lldb::user_id_t trace_id = 3; 532 TraceOptions options; 533 options.setThreadID(thread_id); 534 535 std::future<Status> result = std::async(std::launch::async, [&] { 536 return client.SendGetTraceConfigPacket(trace_id, options); 537 }); 538 539 const char *expected_packet = 540 R"(jTraceConfigRead:{"threadid" : 35,"traceid" : 3})"; 541 std::string response1 = 542 R"({"buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"})"; 543 std::string response2 = 544 R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])"; 545 HandlePacket(server, expected_packet, response1+response2); 546 ASSERT_TRUE(result.get().Success()); 547 ASSERT_EQ(options.getTraceBufferSize(), 8192); 548 ASSERT_EQ(options.getMetaDataBufferSize(), 8192); 549 ASSERT_EQ(options.getType(), 1); 550 551 auto custom_params = options.getTraceParams(); 552 553 uint64_t psb_value; 554 llvm::StringRef trace_tech_value; 555 556 ASSERT_TRUE(custom_params); 557 ASSERT_EQ(custom_params->GetType(), StructuredData::Type::eTypeDictionary); 558 ASSERT_TRUE( 559 custom_params->GetValueForKeyAsInteger<uint64_t>("psb", psb_value)); 560 ASSERT_EQ(psb_value, 1); 561 ASSERT_TRUE( 562 custom_params->GetValueForKeyAsString("tracetech", trace_tech_value)); 563 ASSERT_STREQ(trace_tech_value.data(), "intel-pt"); 564 565 // Checking error response. 566 std::future<Status> result2 = std::async(std::launch::async, [&] { 567 return client.SendGetTraceConfigPacket(trace_id, options); 568 }); 569 570 HandlePacket(server, expected_packet, "E23"); 571 ASSERT_FALSE(result2.get().Success()); 572 573 // Wrong JSON as response. 574 std::future<Status> result3 = std::async(std::launch::async, [&] { 575 return client.SendGetTraceConfigPacket(trace_id, options); 576 }); 577 578 std::string incorrect_json1 = 579 R"("buffersize" : 8192,"params" : {"psb" : 1,"tracetech" : "intel-pt"})"; 580 std::string incorrect_json2 = 581 R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])"; 582 HandlePacket(server, expected_packet, incorrect_json1+incorrect_json2); 583 ASSERT_FALSE(result3.get().Success()); 584 585 // Wrong JSON as custom_params. 586 std::future<Status> result4 = std::async(std::launch::async, [&] { 587 return client.SendGetTraceConfigPacket(trace_id, options); 588 }); 589 590 std::string incorrect_custom_params1 = 591 R"({"buffersize" : 8192,"params" : "psb" : 1,"tracetech" : "intel-pt"})"; 592 std::string incorrect_custom_params2 = 593 R"(],"metabuffersize" : 8192,"threadid" : 35,"type" : 1}])"; 594 HandlePacket(server, expected_packet, incorrect_custom_params1+ 595 incorrect_custom_params2); 596 ASSERT_FALSE(result4.get().Success()); 597 }