unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

   1 //===-- GDBRemoteClientBaseTest.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/Utility/LinuxSignals.h"
  14 #include "Plugins/Process/gdb-remote/GDBRemoteClientBase.h"
  15 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h"
  16 #include "lldb/Utility/StreamGDBRemote.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/Testing/Support/Error.h"
  19
  20 using namespace lldb_private::process_gdb_remote;
  21 using namespace lldb_private;
  22 using namespace lldb;
  23 typedef GDBRemoteCommunication::PacketResult PacketResult;
  24
  25 namespace {
  26
  27 struct MockDelegate : public GDBRemoteClientBase::ContinueDelegate {
  28   std::string output;
  29   std::string misc_data;
  30   unsigned stop_reply_called = 0;
  31   std::vector<std::string> structured_data_packets;
  32
  33   void HandleAsyncStdout(llvm::StringRef out) { output += out; }
  34   void HandleAsyncMisc(llvm::StringRef data) { misc_data += data; }
  35   void HandleStopReply() { ++stop_reply_called; }
  36
  37   void HandleAsyncStructuredDataPacket(llvm::StringRef data) {
  38     structured_data_packets.push_back(data);
  39   }
  40 };
  41
  42 struct TestClient : public GDBRemoteClientBase {
  43   TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") {
  44     m_send_acks = false;
  45   }
  46 };
  47
  48 class GDBRemoteClientBaseTest : public GDBRemoteTest {
  49 public:
  50   void SetUp() override {
  51     ASSERT_THAT_ERROR(GDBRemoteCommunication::ConnectLocally(client, server),
  52                       llvm::Succeeded());
  53     ASSERT_EQ(TestClient::eBroadcastBitRunPacketSent,
  54               listener_sp->StartListeningForEvents(
  55                   &client, TestClient::eBroadcastBitRunPacketSent));
  56   }
  57
  58 protected:
  59   TestClient client;
  60   MockServer server;
  61   MockDelegate delegate;
  62   ListenerSP listener_sp = Listener::MakeListener("listener");
  63
  64   StateType SendCPacket(StringExtractorGDBRemote &response) {
  65     return client.SendContinuePacketAndWaitForResponse(delegate, LinuxSignals(),
  66                                                        "c", response);
  67   }
  68
  69   void WaitForRunEvent() {
  70     EventSP event_sp;
  71     listener_sp->GetEventForBroadcasterWithType(
  72         &client, TestClient::eBroadcastBitRunPacketSent, event_sp, llvm::None);
  73   }
  74 };
  75
  76 } // end anonymous namespace
  77
  78 TEST_F(GDBRemoteClientBaseTest, SendContinueAndWait) {
  79   StringExtractorGDBRemote response;
  80
  81   // Continue. The inferior will stop with a signal.
  82   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
  83   ASSERT_EQ(eStateStopped, SendCPacket(response));
  84   ASSERT_EQ("T01", response.GetStringRef());
  85   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  86   ASSERT_EQ("c", response.GetStringRef());
  87
  88   // Continue. The inferior will exit.
  89   ASSERT_EQ(PacketResult::Success, server.SendPacket("W01"));
  90   ASSERT_EQ(eStateExited, SendCPacket(response));
  91   ASSERT_EQ("W01", response.GetStringRef());
  92   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
  93   ASSERT_EQ("c", response.GetStringRef());
  94
  95   // Continue. The inferior will get killed.
  96   ASSERT_EQ(PacketResult::Success, server.SendPacket("X01"));
  97   ASSERT_EQ(eStateExited, SendCPacket(response));
  98   ASSERT_EQ("X01", response.GetStringRef());
  99   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 100   ASSERT_EQ("c", response.GetStringRef());
 101 }
 102
 103 TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncSignal) {
 104   StringExtractorGDBRemote continue_response, response;
 105
 106   // SendAsyncSignal should do nothing when we are not running.
 107   ASSERT_FALSE(client.SendAsyncSignal(0x47));
 108
 109   // Continue. After the run packet is sent, send an async signal.
 110   std::future<StateType> continue_state = std::async(
 111       std::launch::async, [&] { return SendCPacket(continue_response); });
 112   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 113   ASSERT_EQ("c", response.GetStringRef());
 114   WaitForRunEvent();
 115
 116   std::future<bool> async_result = std::async(
 117       std::launch::async, [&] { return client.SendAsyncSignal(0x47); });
 118
 119   // First we'll get interrupted.
 120   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 121   ASSERT_EQ("\x03", response.GetStringRef());
 122   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
 123
 124   // Then we get the signal packet.
 125   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 126   ASSERT_EQ("C47", response.GetStringRef());
 127   ASSERT_TRUE(async_result.get());
 128
 129   // And we report back a signal stop.
 130   ASSERT_EQ(PacketResult::Success, server.SendPacket("T47"));
 131   ASSERT_EQ(eStateStopped, continue_state.get());
 132   ASSERT_EQ("T47", continue_response.GetStringRef());
 133 }
 134
 135 TEST_F(GDBRemoteClientBaseTest, SendContinueAndAsyncPacket) {
 136   StringExtractorGDBRemote continue_response, async_response, response;
 137   const bool send_async = true;
 138
 139   // Continue. After the run packet is sent, send an async packet.
 140   std::future<StateType> continue_state = std::async(
 141       std::launch::async, [&] { return SendCPacket(continue_response); });
 142   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 143   ASSERT_EQ("c", response.GetStringRef());
 144   WaitForRunEvent();
 145
 146   // Sending without async enabled should fail.
 147   ASSERT_EQ(
 148       PacketResult::ErrorSendFailed,
 149       client.SendPacketAndWaitForResponse("qTest1", response, !send_async));
 150
 151   std::future<PacketResult> async_result = std::async(std::launch::async, [&] {
 152     return client.SendPacketAndWaitForResponse("qTest2", async_response,
 153                                                send_async);
 154   });
 155
 156   // First we'll get interrupted.
 157   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 158   ASSERT_EQ("\x03", response.GetStringRef());
 159   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
 160
 161   // Then we get the async packet.
 162   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 163   ASSERT_EQ("qTest2", response.GetStringRef());
 164
 165   // Send the response and receive it.
 166   ASSERT_EQ(PacketResult::Success, server.SendPacket("QTest2"));
 167   ASSERT_EQ(PacketResult::Success, async_result.get());
 168   ASSERT_EQ("QTest2", async_response.GetStringRef());
 169
 170   // And we get resumed again.
 171   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 172   ASSERT_EQ("c", response.GetStringRef());
 173   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
 174   ASSERT_EQ(eStateStopped, continue_state.get());
 175   ASSERT_EQ("T01", continue_response.GetStringRef());
 176 }
 177
 178 TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt) {
 179   StringExtractorGDBRemote continue_response, response;
 180
 181   // Interrupt should do nothing when we're not running.
 182   ASSERT_FALSE(client.Interrupt());
 183
 184   // Continue. After the run packet is sent, send an interrupt.
 185   std::future<StateType> continue_state = std::async(
 186       std::launch::async, [&] { return SendCPacket(continue_response); });
 187   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 188   ASSERT_EQ("c", response.GetStringRef());
 189   WaitForRunEvent();
 190
 191   std::future<bool> async_result =
 192       std::async(std::launch::async, [&] { return client.Interrupt(); });
 193
 194   // We get interrupted.
 195   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 196   ASSERT_EQ("\x03", response.GetStringRef());
 197   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
 198
 199   // And that's it.
 200   ASSERT_EQ(eStateStopped, continue_state.get());
 201   ASSERT_EQ("T13", continue_response.GetStringRef());
 202   ASSERT_TRUE(async_result.get());
 203 }
 204
 205 TEST_F(GDBRemoteClientBaseTest, SendContinueAndLateInterrupt) {
 206   StringExtractorGDBRemote continue_response, response;
 207
 208   // Continue. After the run packet is sent, send an interrupt.
 209   std::future<StateType> continue_state = std::async(
 210       std::launch::async, [&] { return SendCPacket(continue_response); });
 211   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 212   ASSERT_EQ("c", response.GetStringRef());
 213   WaitForRunEvent();
 214
 215   std::future<bool> async_result =
 216       std::async(std::launch::async, [&] { return client.Interrupt(); });
 217
 218   // However, the target stops due to a different reason than the original
 219   // interrupt.
 220   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 221   ASSERT_EQ("\x03", response.GetStringRef());
 222   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
 223   ASSERT_EQ(eStateStopped, continue_state.get());
 224   ASSERT_EQ("T01", continue_response.GetStringRef());
 225   ASSERT_TRUE(async_result.get());
 226
 227   // The subsequent continue packet should work normally.
 228   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
 229   ASSERT_EQ(eStateStopped, SendCPacket(response));
 230   ASSERT_EQ("T01", response.GetStringRef());
 231   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 232   ASSERT_EQ("c", response.GetStringRef());
 233 }
 234
 235 TEST_F(GDBRemoteClientBaseTest, SendContinueAndInterrupt2PacketBug) {
 236   StringExtractorGDBRemote continue_response, async_response, response;
 237   const bool send_async = true;
 238
 239   // Interrupt should do nothing when we're not running.
 240   ASSERT_FALSE(client.Interrupt());
 241
 242   // Continue. After the run packet is sent, send an async signal.
 243   std::future<StateType> continue_state = std::async(
 244       std::launch::async, [&] { return SendCPacket(continue_response); });
 245   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 246   ASSERT_EQ("c", response.GetStringRef());
 247   WaitForRunEvent();
 248
 249   std::future<bool> interrupt_result =
 250       std::async(std::launch::async, [&] { return client.Interrupt(); });
 251
 252   // We get interrupted. We'll send two packets to simulate a buggy stub.
 253   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 254   ASSERT_EQ("\x03", response.GetStringRef());
 255   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
 256   ASSERT_EQ(PacketResult::Success, server.SendPacket("T13"));
 257
 258   // We should stop.
 259   ASSERT_EQ(eStateStopped, continue_state.get());
 260   ASSERT_EQ("T13", continue_response.GetStringRef());
 261   ASSERT_TRUE(interrupt_result.get());
 262
 263   // Packet stream should remain synchronized.
 264   std::future<PacketResult> send_result = std::async(std::launch::async, [&] {
 265     return client.SendPacketAndWaitForResponse("qTest", async_response,
 266                                                !send_async);
 267   });
 268   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 269   ASSERT_EQ("qTest", response.GetStringRef());
 270   ASSERT_EQ(PacketResult::Success, server.SendPacket("QTest"));
 271   ASSERT_EQ(PacketResult::Success, send_result.get());
 272   ASSERT_EQ("QTest", async_response.GetStringRef());
 273 }
 274
 275 TEST_F(GDBRemoteClientBaseTest, SendContinueDelegateInterface) {
 276   StringExtractorGDBRemote response;
 277
 278   // Continue. We'll have the server send a bunch of async packets before it
 279   // stops.
 280   ASSERT_EQ(PacketResult::Success, server.SendPacket("O4142"));
 281   ASSERT_EQ(PacketResult::Success, server.SendPacket("Apro"));
 282   ASSERT_EQ(PacketResult::Success, server.SendPacket("O4344"));
 283   ASSERT_EQ(PacketResult::Success, server.SendPacket("Afile"));
 284   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
 285   ASSERT_EQ(eStateStopped, SendCPacket(response));
 286   ASSERT_EQ("T01", response.GetStringRef());
 287   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 288   ASSERT_EQ("c", response.GetStringRef());
 289
 290   EXPECT_EQ("ABCD", delegate.output);
 291   EXPECT_EQ("profile", delegate.misc_data);
 292   EXPECT_EQ(1u, delegate.stop_reply_called);
 293 }
 294
 295 TEST_F(GDBRemoteClientBaseTest, SendContinueDelegateStructuredDataReceipt) {
 296   // Build the plain-text version of the JSON data we will have the
 297   // server send.
 298   const std::string json_payload =
 299       "{ \"type\": \"MyFeatureType\", "
 300       "  \"elements\": [ \"entry1\", \"entry2\" ] }";
 301   const std::string json_packet = "JSON-async:" + json_payload;
 302
 303   // Escape it properly for transit.
 304   StreamGDBRemote stream;
 305   stream.PutEscapedBytes(json_packet.c_str(), json_packet.length());
 306   stream.Flush();
 307
 308   StringExtractorGDBRemote response;
 309
 310   // Send async structured data packet, then stop.
 311   ASSERT_EQ(PacketResult::Success, server.SendPacket(stream.GetData()));
 312   ASSERT_EQ(PacketResult::Success, server.SendPacket("T01"));
 313   ASSERT_EQ(eStateStopped, SendCPacket(response));
 314   ASSERT_EQ("T01", response.GetStringRef());
 315   ASSERT_EQ(1ul, delegate.structured_data_packets.size());
 316
 317   // Verify the packet contents.  It should have been unescaped upon packet
 318   // reception.
 319   ASSERT_EQ(json_packet, delegate.structured_data_packets[0]);
 320 }
 321
 322 TEST_F(GDBRemoteClientBaseTest, InterruptNoResponse) {
 323   StringExtractorGDBRemote continue_response, response;
 324
 325   // Continue. After the run packet is sent, send an interrupt.
 326   std::future<StateType> continue_state = std::async(
 327       std::launch::async, [&] { return SendCPacket(continue_response); });
 328   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 329   ASSERT_EQ("c", response.GetStringRef());
 330   WaitForRunEvent();
 331
 332   std::future<bool> async_result =
 333       std::async(std::launch::async, [&] { return client.Interrupt(); });
 334
 335   // We get interrupted, but we don't send a stop packet.
 336   ASSERT_EQ(PacketResult::Success, server.GetPacket(response));
 337   ASSERT_EQ("\x03", response.GetStringRef());
 338
 339   // The functions should still terminate (after a timeout).
 340   ASSERT_TRUE(async_result.get());
 341   ASSERT_EQ(eStateInvalid, continue_state.get());
 342 }
 343
 344 TEST_F(GDBRemoteClientBaseTest, SendPacketAndReceiveResponseWithOutputSupport) {
 345   StringExtractorGDBRemote response;
 346   StreamString command_output;
 347
 348   ASSERT_EQ(PacketResult::Success, server.SendPacket("O"));
 349   ASSERT_EQ(PacketResult::Success, server.SendPacket("O48656c6c6f2c"));
 350   ASSERT_EQ(PacketResult::Success, server.SendPacket("O20"));
 351   ASSERT_EQ(PacketResult::Success, server.SendPacket("O"));
 352   ASSERT_EQ(PacketResult::Success, server.SendPacket("O776f726c64"));
 353   ASSERT_EQ(PacketResult::Success, server.SendPacket("OK"));
 354
 355   PacketResult result = client.SendPacketAndReceiveResponseWithOutputSupport(
 356       "qRcmd,test", response, true,
 357       [&command_output](llvm::StringRef output) { command_output << output; });
 358
 359   ASSERT_EQ(PacketResult::Success, result);
 360   ASSERT_EQ("OK", response.GetStringRef());
 361   ASSERT_EQ("Hello, world", command_output.GetString().str());
 362 }