Merge lp:~3v1n0/unity/glib-signals-blocking into lp:unity

[Marco Trevisan (Treviño)]

GLibSignal: allow to block, unblock signals

Added support also to SignalManager, changed a bit the interface

[Andrea Azzarone (azzar1)]

+1

review: Approve

=== modified file 'UnityCore/GLibSignal-inl.h'
--- UnityCore/GLibSignal-inl.h	2014-10-15 05:16:46 +0000
+++ UnityCore/GLibSignal-inl.h	2017-07-12 17:46:51 +0000
@@ -34,11 +34,11 @@
 }
 
 template <typename R, typename G, typename... Ts>
-void Signal<R, G, Ts...>::Connect(G object, std::string const& signal_name,
+bool Signal<R, G, Ts...>::Connect(G object, std::string const& signal_name,
                                   SignalCallback const& callback)
 {
   if (!callback || !G_IS_OBJECT(object) || signal_name.empty())
-    return;
+    return false;
 
   Disconnect();
 
@@ -47,6 +47,8 @@
   callback_ = callback;
   connection_id_ = g_signal_connect(object_, signal_name.c_str(), G_CALLBACK(Callback), this);
   g_object_add_weak_pointer(object_, reinterpret_cast<gpointer*>(&object_));
+
+  return true;
 }
 
 template <typename R, typename G, typename... Ts>
@@ -59,6 +61,12 @@
   return R();
 }
 
+template <typename R, typename G, typename... Ts>
+SignalBase::Ptr SignalManager::Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const& callback)
+{
+  return Add(std::make_shared<Signal<R, G, Ts...>>(object, signal_name, callback));
+}
+
 }
 }
 

=== modified file 'UnityCore/GLibSignal.cpp'
--- UnityCore/GLibSignal.cpp	2012-08-15 16:58:14 +0000
+++ UnityCore/GLibSignal.cpp	2017-07-12 17:46:51 +0000
@@ -35,16 +35,46 @@
   Disconnect();
 }
 
-void SignalBase::Disconnect()
+bool SignalBase::Disconnect()
 {
+  bool disconnected = false;
+
   if (connection_id_ && G_IS_OBJECT(object_))
   {
     g_signal_handler_disconnect(object_, connection_id_);
     g_object_remove_weak_pointer(object_, reinterpret_cast<gpointer*>(&object_));
+    disconnected = true;
   }
 
   object_ = nullptr;
   connection_id_ = 0;
+  return disconnected;
+}
+
+bool SignalBase::Block() const
+{
+  bool blocked = false;
+
+  if (connection_id_ && G_IS_OBJECT(object_))
+  {
+    g_signal_handler_block(object_, connection_id_);
+    blocked = true;
+  }
+
+  return blocked;
+}
+
+bool SignalBase::Unblock() const
+{
+  bool unblocked = false;
+
+  if (connection_id_ && G_IS_OBJECT(object_))
+  {
+    g_signal_handler_unblock(object_, connection_id_);
+    unblocked = true;
+  }
+
+  return unblocked;
 }
 
 GObject* SignalBase::object() const
@@ -75,57 +105,73 @@
 // was too messy to try and write a copy constructor/operator that would steal
 // from "other" and make the new one the owner. Not only did it create
 // opportunity for random bugs, it also made the API bad.
-void SignalManager::Add(SignalBase* signal)
+SignalBase::Ptr SignalManager::Add(SignalBase* signal)
 {
-  Add(SignalBase::Ptr(signal));
+  return Add(SignalBase::Ptr(signal));
 }
 
-void SignalManager::Add(SignalBase::Ptr const& signal)
+SignalBase::Ptr SignalManager::Add(SignalBase::Ptr const& signal)
 {
   connections_.push_back(signal);
   g_object_weak_ref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
-}
-
-void SignalManager::OnObjectDestroyed(SignalManager* self, GObject* old_obj)
-{
-  for (auto it = self->connections_.begin(); it != self->connections_.end();)
-  {
-    auto const& signal = *it;
-
-    // When an object has been destroyed, the signal member is nullified,
-    // so at this point we can be sure that removing signal with a null object,
-    // means removing invalid signals.
-    if (!signal->object())
-    {
-      it = self->connections_.erase(it);
-    }
-    else
-    {
-      ++it;
-    }
-  }
+  return signal;
 }
 
 // This uses void* to keep in line with the g_signal* functions
 // (it allows you to pass in a GObject without casting up).
-void SignalManager::Disconnect(void* object, std::string const& signal_name)
+bool SignalManager::ForeachMatchedSignal(void* object, std::string const& signal_name, std::function<void(SignalBase::Ptr const&)> action, bool erase_after)
 {
-  bool all_signals = signal_name.empty();
+  bool action_performed = false;
+  bool all_objects = (object == reinterpret_cast<void*>(std::numeric_limits<uintptr_t>::max()));
+  bool all_signals = all_objects || signal_name.empty();
 
   for (auto it = connections_.begin(); it != connections_.end();)
   {
     auto const& signal = *it;
 
-    if (signal->object() == object && (all_signals || signal->name() == signal_name))
+    if ((all_objects || signal->object() == object) && (all_signals || signal->name() == signal_name))
     {
-      g_object_weak_unref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
-      it = connections_.erase(it);
+      if (action)
+      {
+        action_performed = true;
+        action(signal);
+      }
+
+      it = erase_after ? connections_.erase(it) : ++it;
     }
     else
     {
       ++it;
     }
   }
+
+  return action_performed;
+}
+
+void SignalManager::OnObjectDestroyed(SignalManager* self, GObject* old_obj)
+{
+  self->ForeachMatchedSignal(nullptr, "", nullptr, /*erase_after*/ true);
+}
+
+bool SignalManager::Block(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    signal->Block();
+  });
+}
+
+bool SignalManager::Unblock(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    signal->Unblock();
+  });
+}
+
+bool SignalManager::Disconnect(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    g_object_weak_unref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
+  }, true);
 }
 
 }

=== modified file 'UnityCore/GLibSignal.h'
--- UnityCore/GLibSignal.h	2012-08-15 16:58:14 +0000
+++ UnityCore/GLibSignal.h	2017-07-12 17:46:51 +0000
@@ -21,6 +21,7 @@
 #ifndef UNITY_GLIB_SIGNAL_H
 #define UNITY_GLIB_SIGNAL_H
 
+#include <limits>
 #include <string>
 #include <vector>
 #include <memory>
@@ -39,7 +40,10 @@
 
   virtual ~SignalBase();
 
-  void Disconnect();
+  bool Disconnect();
+
+  bool Block() const;
+  bool Unblock() const;
 
   GObject* object() const;
   std::string const& name() const;
@@ -71,9 +75,9 @@
 #endif
 
   inline Signal() {};
-  inline Signal(G object, std::string const& signal_name, SignalCallback const& callback);
+  inline Signal(G object, std::string const& signal_name, SignalCallback const&);
 
-  inline void Connect(G Object, std::string const& signal_name, SignalCallback const& callback);
+  inline bool Connect(G Object, std::string const& signal_name, SignalCallback const&);
 
 private:
   static R Callback(G Object, Ts... vs, Signal* self);
@@ -86,17 +90,18 @@
 public:
   SignalManager();
   ~SignalManager();
-  void Add(SignalBase* signal);
-  void Add(SignalBase::Ptr const& signal);
+  SignalBase::Ptr Add(SignalBase* signal);
+  SignalBase::Ptr Add(SignalBase::Ptr const& signal);
   template <typename R, typename G, typename... Ts>
-  void Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const& callback)
-  {
-    Add(std::make_shared<Signal<R, G, Ts...>>(object, signal_name, callback));
-  }
-
-  void Disconnect(void* object, std::string const& signal_name = "");
+  SignalBase::Ptr Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const&);
+
+  bool Block(void* object = (void*) std::numeric_limits<uintptr_t>::max(), std::string const& signal_name = "");
+  bool Unblock(void* object = (void*) std::numeric_limits<uintptr_t>::max(), std::string const& signal_name = "");
+
+  bool Disconnect(void* object, std::string const& signal_name = "");
 
 private:
+  bool ForeachMatchedSignal(void* object, std::string const& signal_name, std::function<void(SignalBase::Ptr const&)> action, bool erase_after = false);
   static void OnObjectDestroyed(SignalManager* self, GObject* old_obj);
 
 protected:

=== modified file 'tests/test_glib_signals.cpp'
--- tests/test_glib_signals.cpp	2016-11-29 14:43:12 +0000
+++ tests/test_glib_signals.cpp	2017-07-12 17:46:51 +0000
@@ -34,7 +34,8 @@
 
   virtual ~TestGLibSignals()
   {
-    g_object_unref(test_signals_);
+    if (test_signals_)
+      g_object_unref(test_signals_);
   }
 
   void Signal0Callback(TestSignals* signals)
@@ -136,8 +137,8 @@
 TEST_F(TestGLibSignals, TestSignal0)
 {
   Signal<void, TestSignals*> signal;
-  signal.Connect(test_signals_, "signal0",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal0");
 
@@ -148,8 +149,8 @@
 TEST_F(TestGLibSignals, TestSignal1)
 {
   Signal<void, TestSignals*, const char*> signal;
-  signal.Connect(test_signals_, "signal1",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal1",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal1Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal1", "test");
 
@@ -161,8 +162,8 @@
 TEST_F(TestGLibSignals, TestSignal2)
 {
   Signal<void, TestSignals*, const char*, int> signal;
-  signal.Connect(test_signals_, "signal2",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal2Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal2",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal2Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal2", "test", 100);
 
@@ -175,8 +176,8 @@
 TEST_F(TestGLibSignals, TestSignal3)
 {
   Signal<void, TestSignals*, const char*, int, float> signal;
-  signal.Connect(test_signals_, "signal3",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal3Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal3",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal3Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal3", "test", 100, 200.0f);
 
@@ -191,8 +192,8 @@
 TEST_F(TestGLibSignals, TestSignal4)
 {
   Signal<void, TestSignals*, const char*, int, float, double> signal;
-  signal.Connect(test_signals_, "signal4",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal4Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal4",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal4Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal4", "test", 100, 200.0f, 300.00);
 
@@ -207,8 +208,8 @@
 TEST_F(TestGLibSignals, TestSignal5)
 {
   Signal<void, TestSignals*, const char*, int, float, double, gboolean> signal;
-  signal.Connect(test_signals_, "signal5",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal5Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal5",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal5Callback)));
 
   g_signal_emit_by_name(test_signals_, "signal5", "test", 100, 200.0f, 300.00,
                         TRUE);
@@ -226,8 +227,8 @@
 TEST_F(TestGLibSignals, TestSignal6)
 {
   Signal<gboolean, TestSignals*, const char*, int, float, double, gboolean, char> signal;
-  signal.Connect(test_signals_, "signal6",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal6Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal6",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal6Callback)));
 
   gboolean ret = FALSE;
   g_signal_emit_by_name(test_signals_, "signal6", "test", 100, 200.0f, 300.00,
@@ -243,12 +244,46 @@
   EXPECT_EQ(ret, TRUE);
 }
 
+TEST_F(TestGLibSignals, TestBlock)
+{
+  Signal<void, TestSignals*> signal;
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  EXPECT_TRUE(signal.Block());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_FALSE(signal0_received_);
+
+  signal0_received_ = false;
+  EXPECT_TRUE(signal.Unblock());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+}
+
+TEST_F(TestGLibSignals, TestUnblock)
+{
+  Signal<void, TestSignals*> signal;
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  EXPECT_TRUE(signal.Unblock());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+
+  signal0_received_ = false;
+  EXPECT_TRUE(signal.Block());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_FALSE(signal0_received_);
+}
+
 TEST_F(TestGLibSignals, TestDisconnection)
 {
   Signal<void, TestSignals*> signal;
-  signal.Connect(test_signals_, "signal0",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
-  signal.Disconnect();
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
+  EXPECT_TRUE(signal.Disconnect());
 
   g_signal_emit_by_name(test_signals_, "signal0");
 
@@ -259,8 +294,8 @@
 {
   {
     Signal<void, TestSignals*> signal;
-    signal.Connect(test_signals_, "signal0",
-                   sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+    ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                               sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
   }
 
   g_signal_emit_by_name(test_signals_, "signal0");
@@ -271,8 +306,8 @@
 TEST_F(TestGLibSignals, TestCleanDestruction)
 {
   Signal<void, TestSignals*> signal;
-  signal.Connect(test_signals_, "signal0",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
   g_clear_object(&test_signals_);
   EXPECT_EQ(signal.object(), nullptr);
 }
@@ -280,11 +315,11 @@
 TEST_F(TestGLibSignals, TestConnectReplacePreviousConnection)
 {
   Signal<void, TestSignals*> signal;
-  signal.Connect(test_signals_, "signal0",
-                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0",
+                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
 
   unsigned signal0_num_cb = 0;
-  signal.Connect(test_signals_, "signal0", [&] (TestSignals*) {++signal0_num_cb;});
+  ASSERT_TRUE(signal.Connect(test_signals_, "signal0", [&] (TestSignals*) {++signal0_num_cb;}));
 
   g_signal_emit_by_name(test_signals_, "signal0");
 
@@ -302,27 +337,62 @@
 {
   MockSignalManager manager;
 
-  manager.Add(new Signal<void, TestSignals*>(test_signals_,
-                                             "signal0",
-                                             sigc::mem_fun(this, &TestGLibSignals::Signal0Callback)));
-  manager.Add(new Signal<void, TestSignals*, const char*>(test_signals_,
-                                                          "signal1",
-                                                          sigc::mem_fun(this, &TestGLibSignals::Signal1Callback)));
-  manager.Add(new Signal<void, TestSignals*, const char*, int>(test_signals_,
-                                                               "signal2",
-                                                               sigc::mem_fun(this, &TestGLibSignals::Signal2Callback)));
-  manager.Add(new Signal<void, TestSignals*, const char*, int, float>(test_signals_,
-                                                                      "signal3",
-                                                                      sigc::mem_fun(this, &TestGLibSignals::Signal3Callback)));
-  manager.Add(new Signal<void, TestSignals*, const char*, int, float, double>(test_signals_,
-                                                                              "signal4",
-                                                                              sigc::mem_fun(this, &TestGLibSignals::Signal4Callback)));
-  manager.Add(new Signal<void, TestSignals*, const char*, int, float, double, gboolean>(test_signals_,
-              "signal5",
-              sigc::mem_fun(this, &TestGLibSignals::Signal5Callback)));
-  manager.Add(new Signal<gboolean, TestSignals*, const char*, int, float, double, gboolean, char>(test_signals_,
-              "signal6",
-              sigc::mem_fun(this, &TestGLibSignals::Signal6Callback)));
+  auto signal0 = \
+    std::make_shared<Signal<void, TestSignals*>>(test_signals_,
+                                                 "signal0",
+                                                 sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  auto signal0_added = manager.Add(signal0);
+  ASSERT_NE(nullptr, signal0_added);
+  EXPECT_EQ(signal0, signal0_added);
+
+  auto signal1 = \
+    std::make_shared<Signal<void, TestSignals*, const char*>>(test_signals_,
+                                                              "signal1",
+                                                              sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
+  auto signal1_added = manager.Add(signal1);
+  ASSERT_NE(nullptr, signal1_added);
+  EXPECT_EQ(signal1, signal1_added);
+
+  auto signal2 = \
+    std::make_shared<Signal<void, TestSignals*, const char*, int>>(test_signals_,
+                                                                   "signal2",
+                                                                   sigc::mem_fun(this, &TestGLibSignals::Signal2Callback));
+  auto signal2_added = manager.Add(signal2);
+  ASSERT_NE(nullptr, signal2_added);
+  EXPECT_EQ(signal2, signal2_added);
+
+  auto signal3 = \
+    std::make_shared<Signal<void, TestSignals*, const char*, int, float>>(test_signals_,
+                                                                          "signal3",
+                                                                          sigc::mem_fun(this, &TestGLibSignals::Signal3Callback));
+  auto signal3_added = manager.Add(signal3);
+  ASSERT_NE(nullptr, signal3_added);
+  EXPECT_EQ(signal3, signal3_added);
+
+  auto signal4 = \
+    std::make_shared<Signal<void, TestSignals*, const char*, int, float, double>>(test_signals_,
+                                                                                  "signal4",
+                                                                                  sigc::mem_fun(this, &TestGLibSignals::Signal4Callback));
+  auto signal4_added = manager.Add(signal4);
+  ASSERT_NE(nullptr, signal4_added);
+  EXPECT_EQ(signal4, signal4_added);
+
+  auto signal5 = \
+    std::make_shared<Signal<void, TestSignals*, const char*, int, float, double, gboolean>>(test_signals_,
+                                                                                            "signal5",
+                                                                                            sigc::mem_fun(this, &TestGLibSignals::Signal5Callback));
+  auto signal5_added = manager.Add(signal5);
+  ASSERT_NE(nullptr, signal5_added);
+  EXPECT_EQ(signal5, signal5_added);
+
+  auto signal6 = \
+    std::make_shared<Signal<gboolean, TestSignals*, const char*, int, float, double, gboolean, char>>(test_signals_,
+                                                                                                      "signal6",
+                                                                                                      sigc::mem_fun(this, &TestGLibSignals::Signal6Callback));
+  auto signal6_added = manager.Add(signal6);
+  ASSERT_NE(nullptr, signal6_added);
+  EXPECT_EQ(signal6, signal6_added);
+
 
   EXPECT_EQ(manager.GetConnections().size(), 7u);
 }
@@ -331,19 +401,20 @@
 {
   MockSignalManager manager;
 
-  manager.Add<void, TestSignals*>(test_signals_, "signal0",
-                                  sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
-  manager.Add<void, TestSignals*, const char*>(test_signals_, "signal1",
-                                               sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
-  manager.Add<void, TestSignals*, const char*, int>(test_signals_, "signal2",
-                                                    sigc::mem_fun(this, &TestGLibSignals::Signal2Callback));
-  manager.Add<void, TestSignals*, const char*, int, float>(test_signals_, "signal3",
-                                                           sigc::mem_fun(this, &TestGLibSignals::Signal3Callback));
-  manager.Add<void, TestSignals*, const char*, int, float, double>(test_signals_, "signal4",
-                                                                   sigc::mem_fun(this, &TestGLibSignals::Signal4Callback));
-  manager.Add<void, TestSignals*, const char*, int, float, double, gboolean>(test_signals_, "signal5",
-                                                                             sigc::mem_fun(this, &TestGLibSignals::Signal5Callback));
-  manager.Add<gboolean, TestSignals*, const char*, int, float, double, gboolean, char>(test_signals_, "signal6", sigc::mem_fun(this, &TestGLibSignals::Signal6Callback));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*>(test_signals_, "signal0",
+                                                      sigc::mem_fun(this, &TestGLibSignals::Signal0Callback))));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*, const char*>(test_signals_, "signal1",
+                                                                   sigc::mem_fun(this, &TestGLibSignals::Signal1Callback))));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*, const char*, int>(test_signals_, "signal2",
+                                                                        sigc::mem_fun(this, &TestGLibSignals::Signal2Callback))));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*, const char*, int, float>(test_signals_, "signal3",
+                                                                               sigc::mem_fun(this, &TestGLibSignals::Signal3Callback))));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*, const char*, int, float, double>(test_signals_, "signal4",
+                                                                                       sigc::mem_fun(this, &TestGLibSignals::Signal4Callback))));
+  EXPECT_NE(nullptr, (manager.Add<void, TestSignals*, const char*, int, float, double, gboolean>(test_signals_, "signal5",
+                                                                                                 sigc::mem_fun(this, &TestGLibSignals::Signal5Callback))));
+  EXPECT_NE(nullptr, (manager.Add<gboolean, TestSignals*, const char*, int, float, double, gboolean, char>(test_signals_, "signal6",
+                                                                                                           sigc::mem_fun(this, &TestGLibSignals::Signal6Callback))));
 
   EXPECT_EQ(manager.GetConnections().size(), 7u);
 }
@@ -399,6 +470,73 @@
   EXPECT_FALSE(signal0_received_);
 }
 
+TEST_F(TestGLibSignals, TestManagerBlock)
+{
+  SignalManager manager;
+
+  manager.Add<void, TestSignals*>(test_signals_,
+                                  "signal0",
+                                  sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  EXPECT_TRUE(manager.Block(test_signals_, "signal0"));
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_FALSE(signal0_received_);
+
+  EXPECT_TRUE(manager.Unblock(test_signals_, "signal0"));
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+}
+
+TEST_F(TestGLibSignals, TestManagerBlockAll)
+{
+  SignalManager manager;
+
+  manager.Add<void, TestSignals*>(test_signals_,
+                                  "signal0",
+                                  sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  manager.Add<void, TestSignals*, const char*>(test_signals_,
+                                               "signal1",
+                                               sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
+  EXPECT_TRUE(manager.Block(test_signals_));
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  g_signal_emit_by_name(test_signals_, "signal1", "blocked");
+  EXPECT_FALSE(signal0_received_);
+  EXPECT_FALSE(signal1_received_);
+
+  EXPECT_TRUE(manager.Unblock(test_signals_));
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+  g_signal_emit_by_name(test_signals_, "signal1", "unblocked");
+  EXPECT_TRUE(signal1_received_);
+}
+
+TEST_F(TestGLibSignals, TestManagerBlockAllObjects)
+{
+  SignalManager manager;
+
+  manager.Add<void, TestSignals*>(test_signals_,
+                                  "signal0",
+                                  sigc::mem_fun(this, &TestGLibSignals::Signal0Callback));
+  manager.Add<void, TestSignals*, const char*>(test_signals_,
+                                               "signal1",
+                                               sigc::mem_fun(this, &TestGLibSignals::Signal1Callback));
+  EXPECT_TRUE(manager.Block());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  g_signal_emit_by_name(test_signals_, "signal1", "blocked");
+  EXPECT_FALSE(signal0_received_);
+  EXPECT_FALSE(signal1_received_);
+
+  EXPECT_TRUE(manager.Unblock());
+
+  g_signal_emit_by_name(test_signals_, "signal0");
+  EXPECT_TRUE(signal0_received_);
+  g_signal_emit_by_name(test_signals_, "signal1", "unblocked");
+  EXPECT_TRUE(signal1_received_);
+}
+
 TEST_F(TestGLibSignals, TestManagerObjectDisconnection)
 {
   SignalManager manager;