unittests/Core/ListenerTest.cpp

   1 //===-- ListenerTest.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
  10 #include "gtest/gtest.h"
  11
  12 #include "lldb/Core/Broadcaster.h"
  13 #include "lldb/Core/Listener.h"
  14 #include <future>
  15 #include <thread>
  16
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 TEST(ListenerTest, GetEventImmediate) {
  21   EventSP event_sp;
  22   Broadcaster broadcaster(nullptr, "test-broadcaster");
  23
  24   // Create a listener, sign it up, make sure it recieves an event.
  25   ListenerSP listener_sp = Listener::MakeListener("test-listener");
  26   const uint32_t event_mask = 1;
  27   ASSERT_EQ(event_mask,
  28             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
  29
  30   const std::chrono::seconds timeout(0);
  31   // Without any events sent, these should return false.
  32   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
  33   EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
  34   EXPECT_FALSE(
  35       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
  36   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
  37       &broadcaster, event_mask, event_sp, timeout));
  38
  39   // Now send events and make sure they get it.
  40   broadcaster.BroadcastEvent(event_mask, nullptr);
  41   EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
  42
  43   broadcaster.BroadcastEvent(event_mask, nullptr);
  44   EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
  45
  46   broadcaster.BroadcastEvent(event_mask, nullptr);
  47   EXPECT_TRUE(
  48       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
  49
  50   broadcaster.BroadcastEvent(event_mask, nullptr);
  51   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
  52       &broadcaster, event_mask * 2, event_sp, timeout));
  53   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
  54       &broadcaster, event_mask, event_sp, timeout));
  55 }
  56
  57 TEST(ListenerTest, GetEventWait) {
  58   EventSP event_sp;
  59   Broadcaster broadcaster(nullptr, "test-broadcaster");
  60
  61   // Create a listener, sign it up, make sure it recieves an event.
  62   ListenerSP listener_sp = Listener::MakeListener("test-listener");
  63   const uint32_t event_mask = 1;
  64   ASSERT_EQ(event_mask,
  65             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
  66
  67   // Without any events sent, these should make a short wait and return false.
  68   std::chrono::microseconds timeout(10);
  69   EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
  70   EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
  71   EXPECT_FALSE(
  72       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
  73   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
  74       &broadcaster, event_mask, event_sp, timeout));
  75
  76   // Now send events and make sure they get it.
  77   broadcaster.BroadcastEvent(event_mask, nullptr);
  78   EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
  79
  80   broadcaster.BroadcastEvent(event_mask, nullptr);
  81   EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
  82
  83   broadcaster.BroadcastEvent(event_mask, nullptr);
  84   EXPECT_TRUE(
  85       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
  86
  87   broadcaster.BroadcastEvent(event_mask, nullptr);
  88   EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
  89       &broadcaster, event_mask * 2, event_sp, timeout));
  90   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
  91       &broadcaster, event_mask, event_sp, timeout));
  92
  93   auto delayed_broadcast = [&] {
  94     std::this_thread::sleep_for(std::chrono::milliseconds(10));
  95     broadcaster.BroadcastEvent(event_mask, nullptr);
  96   };
  97
  98   // These should do an infinite wait at return the event our asynchronous
  99   // broadcast sends.
 100   std::future<void> async_broadcast =
 101       std::async(std::launch::async, delayed_broadcast);
 102   EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
 103   async_broadcast.get();
 104
 105   async_broadcast = std::async(std::launch::async, delayed_broadcast);
 106   EXPECT_TRUE(
 107       listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
 108   async_broadcast.get();
 109
 110   async_broadcast = std::async(std::launch::async, delayed_broadcast);
 111   EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
 112       &broadcaster, event_mask, event_sp, llvm::None));
 113   async_broadcast.get();
 114 }