source/*: Implement heap based userdata
This makes no immediate change to the external interface, but it will
enable us to do things like making copies of the event sources and
support for floating event source types.
Change-Id: Ida73e773eb0869f6f6f21c1e03c61e9ce2b5625c
Signed-off-by: William A. Kennington III <wak@google.com>
diff --git a/src/sdeventplus/source/base.cpp b/src/sdeventplus/source/base.cpp
index 319b510..bd4a42a 100644
--- a/src/sdeventplus/source/base.cpp
+++ b/src/sdeventplus/source/base.cpp
@@ -2,7 +2,7 @@
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/base.hpp>
-#include <type_traits>
+#include <sdeventplus/types.hpp>
#include <utility>
namespace sdeventplus
@@ -10,14 +10,6 @@
namespace source
{
-Base::~Base()
-{
- if (source)
- {
- set_enabled(Enabled::Off);
- }
-}
-
sd_event_source* Base::get() const
{
return source.value();
@@ -52,20 +44,15 @@
&internal::SdEvent::sd_event_source_set_prepare,
event.getSdEvent(), get(),
callback ? prepareCallback : nullptr);
- prepare = std::move(callback);
+ get_userdata().prepare = std::move(callback);
}
catch (...)
{
- prepare = nullptr;
+ get_userdata().prepare = nullptr;
throw;
}
}
-Base::Callback& Base::get_prepare()
-{
- return prepare;
-}
-
bool Base::get_pending() const
{
return internal::callCheck("sd_event_source_get_pending",
@@ -106,41 +93,48 @@
}
Base::Base(const Event& event, sd_event_source* source, std::false_type) :
- event(event), source(std::move(source), event.getSdEvent())
+ event(event), source(std::move(source), event.getSdEvent(), true)
{
- set_userdata();
}
-Base::Base(Base&& other) :
- event(std::move(other.event)), source(std::move(other.source)),
- prepare(std::move(other.prepare))
+Base::Base(const Base& other, sdeventplus::internal::NoOwn) :
+ event(other.get_event(), sdeventplus::internal::NoOwn()),
+ source(other.get(), event.getSdEvent(), false)
{
- set_userdata();
}
-Base& Base::operator=(Base&& other)
+void Base::set_userdata(std::unique_ptr<detail::BaseData> data) const
{
- if (this != &other)
+ internal::callCheck(
+ "sd_event_source_set_destroy_callback",
+ &internal::SdEvent::sd_event_source_set_destroy_callback,
+ event.getSdEvent(), get(), &Base::destroy_userdata);
+ event.getSdEvent()->sd_event_source_set_userdata(get(), data.release());
+}
+
+detail::BaseData& Base::get_userdata() const
+{
+ return *reinterpret_cast<detail::BaseData*>(
+ event.getSdEvent()->sd_event_source_get_userdata(get()));
+}
+
+Base::Callback& Base::get_prepare()
+{
+ return get_userdata().prepare;
+}
+
+void Base::drop(sd_event_source*&& source, const internal::SdEvent*& sdevent,
+ bool& owned)
+{
+ if (owned)
{
- // We need to make sure our current event is not triggered
- // after it gets deleted in the move
- if (source)
- {
- set_enabled(Enabled::Off);
- }
-
- event = std::move(other.event);
- source = std::move(other.source);
- prepare = std::move(other.prepare);
-
- set_userdata();
+ sdevent->sd_event_source_unref(source);
}
- return *this;
}
-void Base::drop(sd_event_source*&& source, const internal::SdEvent*& sdevent)
+void Base::destroy_userdata(void* userdata)
{
- sdevent->sd_event_source_unref(source);
+ delete static_cast<Base*>(userdata);
}
int Base::prepareCallback(sd_event_source* source, void* userdata)
@@ -149,10 +143,15 @@
source, userdata);
}
-void Base::set_userdata()
+namespace detail
{
- event.getSdEvent()->sd_event_source_set_userdata(get(), this);
+
+BaseData::BaseData(const Base& base) :
+ Base(base, sdeventplus::internal::NoOwn())
+{
}
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/base.hpp b/src/sdeventplus/source/base.hpp
index d177079..4c3ed79 100644
--- a/src/sdeventplus/source/base.hpp
+++ b/src/sdeventplus/source/base.hpp
@@ -5,8 +5,10 @@
#include <cstdio>
#include <function2/function2.hpp>
#include <functional>
+#include <memory>
#include <sdeventplus/event.hpp>
#include <sdeventplus/internal/utils.hpp>
+#include <sdeventplus/types.hpp>
#include <stdplus/handle/managed.hpp>
#include <systemd/sd-bus.h>
#include <type_traits>
@@ -28,6 +30,11 @@
OneShot = SD_EVENT_ONESHOT,
};
+namespace detail
+{
+class BaseData;
+} // namespace detail
+
/** @class Base
* @brief The base class for all sources implementing common source methods
* Not instantiated directly by end users
@@ -37,7 +44,9 @@
public:
using Callback = fu2::unique_function<void(Base& source)>;
- virtual ~Base();
+ Base(Base&& other) = default;
+ Base& operator=(Base&& other) = default;
+ virtual ~Base() = default;
/** @brief Gets the underlying sd_event_source
*
@@ -123,17 +132,33 @@
* @param[in] event - The event associated with the source
* @param[in] source - The underlying sd_event_source wrapped
* @param[in] - Signifies that ownership is being transfered
- * @throws SdEventError for underlying sd_event errors
*/
Base(const Event& event, sd_event_source* source, std::false_type);
- // We can't ever copy an event_source because the callback
- // data has to be unique.
- Base(const Base& other) = delete;
- Base& operator=(const Base& other) = delete;
- // We don't want to allow any kind of slicing.
- Base(Base&& other);
- Base& operator=(Base&& other);
+ /** @brief Constructs a basic non-owning event source wrapper
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ */
+ Base(const Base& other, sdeventplus::internal::NoOwn);
+
+ /** @brief Sets the userdata of the source to the passed in source
+ * This needs to be called by all source implementors.
+ *
+ * @param[in] data - The data stored in the userdata slot.
+ * @throws SdEventError for underlying sd_event errors
+ */
+ void set_userdata(std::unique_ptr<detail::BaseData> data) const;
+
+ /** @brief Get the heap allocated version of the Base
+ *
+ * @return A reference to the Base
+ */
+ detail::BaseData& get_userdata() const;
/** @brief Returns a reference to the prepare callback executed for this
* source
@@ -152,8 +177,7 @@
* @param[in] args... - Extra arguments to pass to the callaback
* @return An negative errno on error, or 0 on success
*/
- template <typename Callback, class Source, Callback& (Source::*getter)(),
- typename... Args>
+ template <typename Callback, class Data, auto getter, typename... Args>
static int sourceCallback(const char* name, sd_event_source*,
void* userdata, Args&&... args)
{
@@ -162,26 +186,27 @@
fprintf(stderr, "sdeventplus: %s: Missing userdata\n", name);
return -EINVAL;
}
- Source* source = reinterpret_cast<Source*>(userdata);
- return internal::performCallback(name, (source->*getter)(),
- std::ref(*source),
+ Data& data =
+ static_cast<Data&>(*reinterpret_cast<detail::BaseData*>(userdata));
+ Callback& callback = std::invoke(getter, data);
+ return internal::performCallback(name, callback, std::ref(data),
std::forward<Args>(args)...);
}
private:
static void drop(sd_event_source*&& source,
- const internal::SdEvent*& sdevent);
+ const internal::SdEvent*& sdevent, bool& owned);
- stdplus::Managed<sd_event_source*, const internal::SdEvent*>::Handle<drop>
+ stdplus::Managed<sd_event_source*, const internal::SdEvent*,
+ bool>::Handle<drop>
source;
- Callback prepare;
- /** @brief A helper used to make sure the userdata for the sd-event
- * callback is set to the current source c++ object
+ /** @brief A wrapper around deleting the heap allocated base class
+ * This is needed for calls from sd_event destroy callbacks.
*
- * @throws SdEventError for underlying sd_event errors
+ * @param[in] userdata - The provided userdata for the source
*/
- void set_userdata();
+ static void destroy_userdata(void* userdata);
/** @brief A wrapper around the callback that can be called from sd-event
*
@@ -192,5 +217,21 @@
static int prepareCallback(sd_event_source* source, void* userdata);
};
+namespace detail
+{
+
+class BaseData : public Base
+{
+ private:
+ Base::Callback prepare;
+
+ public:
+ BaseData(const Base& base);
+
+ friend Base;
+};
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/child.cpp b/src/sdeventplus/source/child.cpp
index 9701d82..925a223 100644
--- a/src/sdeventplus/source/child.cpp
+++ b/src/sdeventplus/source/child.cpp
@@ -1,6 +1,8 @@
+#include <memory>
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/child.hpp>
+#include <sdeventplus/types.hpp>
#include <type_traits>
#include <utility>
@@ -10,14 +12,20 @@
{
Child::Child(const Event& event, pid_t pid, int options, Callback&& callback) :
- Base(event, create_source(event, pid, options), std::false_type()),
- callback(std::move(callback))
+ Base(event, create_source(event, pid, options), std::false_type())
+{
+ set_userdata(
+ std::make_unique<detail::ChildData>(*this, std::move(callback)));
+}
+
+Child::Child(const Child& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
{
}
void Child::set_callback(Callback&& callback)
{
- this->callback = std::move(callback);
+ get_userdata().callback = std::move(callback);
}
pid_t Child::get_pid() const
@@ -29,9 +37,14 @@
return pid;
}
+detail::ChildData& Child::get_userdata() const
+{
+ return static_cast<detail::ChildData&>(Base::get_userdata());
+}
+
Child::Callback& Child::get_callback()
{
- return callback;
+ return get_userdata().callback;
}
sd_event_source* Child::create_source(const Event& event, pid_t pid,
@@ -48,9 +61,20 @@
int Child::childCallback(sd_event_source* source, const siginfo_t* si,
void* userdata)
{
- return sourceCallback<Callback, Child, &Child::get_callback>(
+ return sourceCallback<Callback, detail::ChildData, &Child::get_callback>(
"childCallback", source, userdata, si);
}
+namespace detail
+{
+
+ChildData::ChildData(const Child& base, Child::Callback&& callback) :
+ Child(base, sdeventplus::internal::NoOwn()), BaseData(base),
+ callback(std::move(callback))
+{
+}
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/child.hpp b/src/sdeventplus/source/child.hpp
index 4f29994..7022a3c 100644
--- a/src/sdeventplus/source/child.hpp
+++ b/src/sdeventplus/source/child.hpp
@@ -2,6 +2,7 @@
#include <function2/function2.hpp>
#include <sdeventplus/source/base.hpp>
+#include <sdeventplus/types.hpp>
#include <signal.h>
namespace sdeventplus
@@ -9,6 +10,11 @@
namespace source
{
+namespace detail
+{
+class ChildData;
+} // namespace detail
+
/** @class Child
* @brief A wrapper around the sd_event_source child type
* See sd_event_add_child(3) for more information
@@ -28,10 +34,20 @@
* @param[in] options - An OR-ed mask that determines triggers
* See waitid(2) for further information
* @param[in] callback - The function executed on event dispatch
- * @throws SdEventError for underlying sd_event errors
*/
Child(const Event& event, pid_t pid, int options, Callback&& callback);
+ /** @brief Constructs a non-owning child source handler
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ */
+ Child(const Child& other, sdeventplus::internal::NoOwn);
+
/** @brief Sets the callback
*
* @param[in] callback - The function executed on event dispatch
@@ -46,7 +62,11 @@
pid_t get_pid() const;
private:
- Callback callback;
+ /** @brief Returns a reference to the source owned child
+ *
+ * @return A reference to the child
+ */
+ detail::ChildData& get_userdata() const;
/** @brief Returns a reference to the callback executed for this source
*
@@ -75,5 +95,21 @@
void* userdata);
};
+namespace detail
+{
+
+class ChildData : public Child, public BaseData
+{
+ private:
+ Child::Callback callback;
+
+ public:
+ ChildData(const Child& base, Child::Callback&& callback);
+
+ friend Child;
+};
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/event.cpp b/src/sdeventplus/source/event.cpp
index b65322d..eced2ef 100644
--- a/src/sdeventplus/source/event.cpp
+++ b/src/sdeventplus/source/event.cpp
@@ -1,6 +1,8 @@
+#include <memory>
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/event.hpp>
+#include <sdeventplus/types.hpp>
#include <utility>
namespace sdeventplus
@@ -10,19 +12,30 @@
void EventBase::set_callback(Callback&& callback)
{
- this->callback = std::move(callback);
+ get_userdata().callback = std::move(callback);
+}
+
+EventBase::EventBase(const EventBase& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
+{
}
EventBase::EventBase(const char* name, CreateFunc create, const Event& event,
Callback&& callback) :
- Base(event, create_source(name, create, event), std::false_type()),
- callback(std::move(callback))
+ Base(event, create_source(name, create, event), std::false_type())
{
+ set_userdata(
+ std::make_unique<detail::EventBaseData>(*this, std::move(callback)));
+}
+
+detail::EventBaseData& EventBase::get_userdata() const
+{
+ return static_cast<detail::EventBaseData&>(Base::get_userdata());
}
EventBase::Callback& EventBase::get_callback()
{
- return callback;
+ return get_userdata().callback;
}
sd_event_source* EventBase::create_source(const char* name, CreateFunc create,
@@ -36,10 +49,23 @@
int EventBase::eventCallback(sd_event_source* source, void* userdata)
{
- return sourceCallback<Callback, EventBase, &EventBase::get_callback>(
- "eventCallback", source, userdata);
+ return sourceCallback<Callback, detail::EventBaseData,
+ &EventBase::get_callback>("eventCallback", source,
+ userdata);
}
+namespace detail
+{
+
+EventBaseData::EventBaseData(const EventBase& base,
+ EventBase::Callback&& callback) :
+ EventBase(base, sdeventplus::internal::NoOwn()),
+ BaseData(base), callback(std::move(callback))
+{
+}
+
+} // namespace detail
+
Defer::Defer(const Event& event, Callback&& callback) :
EventBase("sd_event_add_defer", &internal::SdEvent::sd_event_add_defer,
event, std::move(callback))
diff --git a/src/sdeventplus/source/event.hpp b/src/sdeventplus/source/event.hpp
index a2ee939..60b1252 100644
--- a/src/sdeventplus/source/event.hpp
+++ b/src/sdeventplus/source/event.hpp
@@ -3,13 +3,20 @@
#include <function2/function2.hpp>
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/source/base.hpp>
+#include <sdeventplus/types.hpp>
#include <systemd/sd-event.h>
+#include <type_traits>
namespace sdeventplus
{
namespace source
{
+namespace detail
+{
+class EventBaseData;
+} // namespace detail
+
/** @class EventBase
* @brief A wrapper around the sd_event_source defer type
* See sd_event_add_defer(3) for more information
@@ -27,6 +34,17 @@
*/
void set_callback(Callback&& callback);
+ /** @brief Constructs a non-owning event source handler
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ */
+ EventBase(const EventBase& other, sdeventplus::internal::NoOwn);
+
protected:
using CreateFunc = decltype(&internal::SdEvent::sd_event_add_exit);
@@ -38,13 +56,16 @@
* @param[in] create - The SdEvent function called to create the source
* @param[in] event - The event to attach the handler
* @param[in] callback - The function executed on event dispatch
- * @throws SdEventError for underlying sd_event errors
*/
EventBase(const char* name, CreateFunc create, const Event& event,
Callback&& callback);
private:
- Callback callback;
+ /** @brief Returns a reference to the source owned event
+ *
+ * @return A reference to the event
+ */
+ detail::EventBaseData& get_userdata() const;
/** @brief Returns a reference to the callback executed for this source
*
@@ -72,6 +93,22 @@
static int eventCallback(sd_event_source* source, void* userdata);
};
+namespace detail
+{
+
+class EventBaseData : public EventBase, public BaseData
+{
+ private:
+ EventBase::Callback callback;
+
+ public:
+ EventBaseData(const EventBase& base, EventBase::Callback&& callback);
+
+ friend EventBase;
+};
+
+} // namespace detail
+
class Defer : public EventBase
{
public:
diff --git a/src/sdeventplus/source/io.cpp b/src/sdeventplus/source/io.cpp
index 9bd4005..3bafd9a 100644
--- a/src/sdeventplus/source/io.cpp
+++ b/src/sdeventplus/source/io.cpp
@@ -1,6 +1,7 @@
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/io.hpp>
+#include <sdeventplus/types.hpp>
#include <type_traits>
#include <utility>
@@ -10,14 +11,19 @@
{
IO::IO(const Event& event, int fd, uint32_t events, Callback&& callback) :
- Base(event, create_source(event, fd, events), std::false_type()),
- callback(std::move(callback))
+ Base(event, create_source(event, fd, events), std::false_type())
+{
+ set_userdata(std::make_unique<detail::IOData>(*this, std::move(callback)));
+}
+
+IO::IO(const IO& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
{
}
void IO::set_callback(Callback&& callback)
{
- this->callback = std::move(callback);
+ get_userdata().callback = std::move(callback);
}
int IO::get_fd() const
@@ -59,9 +65,14 @@
return revents;
}
+detail::IOData& IO::get_userdata() const
+{
+ return static_cast<detail::IOData&>(Base::get_userdata());
+}
+
IO::Callback& IO::get_callback()
{
- return callback;
+ return get_userdata().callback;
}
sd_event_source* IO::create_source(const Event& event, int fd, uint32_t events)
@@ -76,9 +87,20 @@
int IO::ioCallback(sd_event_source* source, int fd, uint32_t revents,
void* userdata)
{
- return sourceCallback<Callback, IO, &IO::get_callback>(
+ return sourceCallback<Callback, detail::IOData, &IO::get_callback>(
"ioCallback", source, userdata, fd, revents);
}
+namespace detail
+{
+
+IOData::IOData(const IO& base, IO::Callback&& callback) :
+ IO(base, sdeventplus::internal::NoOwn()), BaseData(base),
+ callback(std::move(callback))
+{
+}
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/io.hpp b/src/sdeventplus/source/io.hpp
index 409a1fe..ebb9e34 100644
--- a/src/sdeventplus/source/io.hpp
+++ b/src/sdeventplus/source/io.hpp
@@ -4,12 +4,18 @@
#include <function2/function2.hpp>
#include <sdeventplus/source/base.hpp>
#include <systemd/sd-event.h>
+#include <type_traits>
namespace sdeventplus
{
namespace source
{
+namespace detail
+{
+class IOData;
+} // namespace detail
+
/** @class IO
* @brief A wrapper around the sd_event_source IO type
* See sd_event_add_io(3) for more information
@@ -28,10 +34,20 @@
* @param[in] events - The event mask passed which determines triggers
* See epoll_ctl(2) for more info on the mask
* @param[in] callback - The function executed on event dispatch
- * @throws SdEventError for underlying sd_event errors
*/
IO(const Event& event, int fd, uint32_t events, Callback&& callback);
+ /** @brief Constructs a non-owning io source handler
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ */
+ IO(const IO& event, sdeventplus::internal::NoOwn);
+
/** @brief Sets the callback
*
* @param[in] callback - The function executed on event dispatch
@@ -77,7 +93,11 @@
uint32_t get_revents() const;
private:
- Callback callback;
+ /** @brief Returns a reference to the source owned io
+ *
+ * @return A reference to the io
+ */
+ detail::IOData& get_userdata() const;
/** @brief Returns a reference to the callback executed for this source
*
@@ -107,5 +127,21 @@
void* userdata);
};
+namespace detail
+{
+
+class IOData : public IO, public BaseData
+{
+ private:
+ IO::Callback callback;
+
+ public:
+ IOData(const IO& base, IO::Callback&& callback);
+
+ friend IO;
+};
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/signal.cpp b/src/sdeventplus/source/signal.cpp
index a433cb4..97ae171 100644
--- a/src/sdeventplus/source/signal.cpp
+++ b/src/sdeventplus/source/signal.cpp
@@ -1,6 +1,8 @@
+#include <memory>
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/signal.hpp>
+#include <sdeventplus/types.hpp>
#include <type_traits>
#include <utility>
@@ -10,14 +12,20 @@
{
Signal::Signal(const Event& event, int sig, Callback&& callback) :
- Base(event, create_source(event, sig), std::false_type()),
- callback(std::move(callback))
+ Base(event, create_source(event, sig), std::false_type())
+{
+ set_userdata(
+ std::make_unique<detail::SignalData>(*this, std::move(callback)));
+}
+
+Signal::Signal(const Signal& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
{
}
void Signal::set_callback(Callback&& callback)
{
- this->callback = std::move(callback);
+ get_userdata().callback = std::move(callback);
}
int Signal::get_signal() const
@@ -27,9 +35,14 @@
event.getSdEvent(), get());
}
+detail::SignalData& Signal::get_userdata() const
+{
+ return static_cast<detail::SignalData&>(Base::get_userdata());
+}
+
Signal::Callback& Signal::get_callback()
{
- return callback;
+ return get_userdata().callback;
}
sd_event_source* Signal::create_source(const Event& event, int sig)
@@ -44,9 +57,20 @@
int Signal::signalCallback(sd_event_source* source,
const struct signalfd_siginfo* si, void* userdata)
{
- return sourceCallback<Callback, Signal, &Signal::get_callback>(
+ return sourceCallback<Callback, detail::SignalData, &Signal::get_callback>(
"signalCallback", source, userdata, si);
}
+namespace detail
+{
+
+SignalData::SignalData(const Signal& base, Signal::Callback&& callback) :
+ Signal(base, sdeventplus::internal::NoOwn()), BaseData(base),
+ callback(std::move(callback))
+{
+}
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/signal.hpp b/src/sdeventplus/source/signal.hpp
index 08c0eff..d5035d1 100644
--- a/src/sdeventplus/source/signal.hpp
+++ b/src/sdeventplus/source/signal.hpp
@@ -3,6 +3,7 @@
#include <function2/function2.hpp>
#include <sdeventplus/event.hpp>
#include <sdeventplus/source/base.hpp>
+#include <sdeventplus/types.hpp>
#include <sys/signalfd.h>
namespace sdeventplus
@@ -10,6 +11,11 @@
namespace source
{
+namespace detail
+{
+class SignalData;
+} // namespace detail
+
/** @class Signal
* @brief A wrapper around the sd_event_source signal type
* See sd_event_add_signal(3) for more information
@@ -33,6 +39,18 @@
*/
Signal(const Event& event, int sig, Callback&& callback);
+ /** @brief Constructs a non-owning signal source handler
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ * @throws SdEventError for underlying sd_event errors
+ */
+ Signal(const Signal& other, sdeventplus::internal::NoOwn);
+
/** @brief Sets the callback
*
* @param[in] callback - The function executed on event dispatch
@@ -47,7 +65,11 @@
int get_signal() const;
private:
- Callback callback;
+ /** @brief Returns a reference to the source owned signal
+ *
+ * @return A reference to the signal
+ */
+ detail::SignalData& get_userdata() const;
/** @brief Returns a reference to the callback executed for this source
*
@@ -76,5 +98,21 @@
void* userdata);
};
+namespace detail
+{
+
+class SignalData : public Signal, public BaseData
+{
+ private:
+ Signal::Callback callback;
+
+ public:
+ SignalData(const Signal& base, Signal::Callback&& callback);
+
+ friend Signal;
+};
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/time.cpp b/src/sdeventplus/source/time.cpp
index 0b62f29..03c4665 100644
--- a/src/sdeventplus/source/time.cpp
+++ b/src/sdeventplus/source/time.cpp
@@ -1,8 +1,9 @@
-#include <cstdio>
+#include <memory>
#include <sdeventplus/clock.hpp>
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/time.hpp>
+#include <sdeventplus/types.hpp>
#include <type_traits>
#include <utility>
@@ -14,15 +15,22 @@
template <ClockId Id>
Time<Id>::Time(const Event& event, TimePoint time, Accuracy accuracy,
Callback&& callback) :
- Base(event, create_source(event, time, accuracy), std::false_type()),
- callback(std::move(callback))
+ Base(event, create_source(event, time, accuracy), std::false_type())
+{
+ set_userdata(
+ std::make_unique<detail::TimeData<Id>>(*this, std::move(callback)));
+}
+
+template <ClockId Id>
+Time<Id>::Time(const Time<Id>& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
{
}
template <ClockId Id>
void Time<Id>::set_callback(Callback&& callback)
{
- this->callback = std::move(callback);
+ get_userdata().callback = std::move(callback);
}
template <ClockId Id>
@@ -64,9 +72,15 @@
}
template <ClockId Id>
+detail::TimeData<Id>& Time<Id>::get_userdata() const
+{
+ return static_cast<detail::TimeData<Id>&>(Base::get_userdata());
+}
+
+template <ClockId Id>
typename Time<Id>::Callback& Time<Id>::get_callback()
{
- return callback;
+ return get_userdata().callback;
}
template <ClockId Id>
@@ -86,7 +100,7 @@
int Time<Id>::timeCallback(sd_event_source* source, uint64_t usec,
void* userdata)
{
- return sourceCallback<Callback, Time, &Time::get_callback>(
+ return sourceCallback<Callback, detail::TimeData<Id>, &Time::get_callback>(
"timeCallback", source, userdata, TimePoint(SdEventDuration(usec)));
}
@@ -96,5 +110,18 @@
template class Time<ClockId::RealTimeAlarm>;
template class Time<ClockId::BootTimeAlarm>;
+namespace detail
+{
+
+template <ClockId Id>
+TimeData<Id>::TimeData(const Time<Id>& base,
+ typename Time<Id>::Callback&& callback) :
+ Time<Id>(base, sdeventplus::internal::NoOwn()),
+ BaseData(base), callback(std::move(callback))
+{
+}
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/source/time.hpp b/src/sdeventplus/source/time.hpp
index a262588..f7670b5 100644
--- a/src/sdeventplus/source/time.hpp
+++ b/src/sdeventplus/source/time.hpp
@@ -5,6 +5,7 @@
#include <sdeventplus/clock.hpp>
#include <sdeventplus/internal/utils.hpp>
#include <sdeventplus/source/base.hpp>
+#include <sdeventplus/types.hpp>
#include <systemd/sd-event.h>
namespace sdeventplus
@@ -12,6 +13,12 @@
namespace source
{
+namespace detail
+{
+template <ClockId Id>
+class TimeData;
+} // namespace detail
+
/** @class Time<ClockId>
* @brief A wrapper around the sd_event_source time type
* See sd_event_add_time(3) for more information
@@ -40,6 +47,18 @@
Time(const Event& event, TimePoint time, Accuracy accuracy,
Callback&& callback);
+ /** @brief Constructs a non-owning time source handler
+ * Does not own the passed reference to the source because
+ * this is meant to be used only as a reference inside an event
+ * source.
+ * @internal
+ *
+ * @param[in] other - The source wrapper to copy
+ * @param[in] - Signifies that this new copy is non-owning
+ * @throws SdEventError for underlying sd_event errors
+ */
+ Time(const Time& other, sdeventplus::internal::NoOwn);
+
/** @brief Sets the callback
*
* @param[in] callback - The function executed on event dispatch
@@ -75,7 +94,11 @@
void set_accuracy(Accuracy accuracy) const;
private:
- Callback callback;
+ /** @brief Returns a reference to the source owned time
+ *
+ * @return A reference to the time
+ */
+ detail::TimeData<Id>& get_userdata() const;
/** @brief Returns a reference to the callback executed for this source
*
@@ -104,5 +127,22 @@
void* userdata);
};
+namespace detail
+{
+
+template <ClockId Id>
+class TimeData : public Time<Id>, public BaseData
+{
+ private:
+ typename Time<Id>::Callback callback;
+
+ public:
+ TimeData(const Time<Id>& base, typename Time<Id>::Callback&& callback);
+
+ friend Time<Id>;
+};
+
+} // namespace detail
+
} // namespace source
} // namespace sdeventplus
diff --git a/src/sdeventplus/utility/timer.cpp b/src/sdeventplus/utility/timer.cpp
index 638f8e1..d078b06 100644
--- a/src/sdeventplus/utility/timer.cpp
+++ b/src/sdeventplus/utility/timer.cpp
@@ -26,6 +26,15 @@
{
if (this != &other)
{
+ try
+ {
+ timeSource.set_enabled(source::Enabled::Off);
+ }
+ catch (std::bad_optional_access&)
+ {
+ // This is normal for a moved object
+ }
+
expired = std::move(other.expired);
initialized = std::move(other.initialized);
callback = std::move(other.callback);
@@ -55,6 +64,19 @@
}
template <ClockId Id>
+Timer<Id>::~Timer()
+{
+ try
+ {
+ timeSource.set_enabled(source::Enabled::Off);
+ }
+ catch (std::bad_optional_access&)
+ {
+ // This is normal for a moved object
+ }
+}
+
+template <ClockId Id>
void Timer<Id>::set_callback(Callback&& callback)
{
this->callback = std::move(callback);
diff --git a/src/sdeventplus/utility/timer.hpp b/src/sdeventplus/utility/timer.hpp
index bca5566..1453dbe 100644
--- a/src/sdeventplus/utility/timer.hpp
+++ b/src/sdeventplus/utility/timer.hpp
@@ -41,7 +41,7 @@
Timer(Timer&& other);
Timer& operator=(const Timer& other) = delete;
Timer& operator=(Timer&& other);
- virtual ~Timer() = default;
+ virtual ~Timer();
/** @brief Creates a new timer on the given event loop.
* This timer is created enabled by default if passed an interval.
diff --git a/test/source/base.cpp b/test/source/base.cpp
index 27e5bc3..3673e24 100644
--- a/test/source/base.cpp
+++ b/test/source/base.cpp
@@ -1,4 +1,5 @@
#include <cerrno>
+#include <functional>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <memory>
@@ -8,8 +9,10 @@
#include <sdeventplus/internal/sdevent.hpp>
#include <sdeventplus/source/base.hpp>
#include <sdeventplus/test/sdevent.hpp>
+#include <sdeventplus/types.hpp>
#include <string>
#include <systemd/sd-event.h>
+#include <tuple>
#include <type_traits>
#include <utility>
@@ -27,24 +30,48 @@
using UniqueEvent = std::unique_ptr<Event, std::function<void(Event*)>>;
+class BaseImplData;
+
class BaseImpl : public Base
{
public:
- BaseImpl(const Event& event, sd_event_source* source, std::false_type) :
- Base(event, source, std::false_type())
+ BaseImpl(const Event& event, sd_event_source* source, std::false_type);
+
+ BaseImpl(const BaseImpl& other, sdeventplus::internal::NoOwn) :
+ Base(other, sdeventplus::internal::NoOwn())
{
}
using Base::get_prepare;
};
+class BaseImplData : public BaseImpl, public detail::BaseData
+{
+ public:
+ BaseImplData(const BaseImpl& base) :
+ BaseImpl(base, sdeventplus::internal::NoOwn()), BaseData(base)
+ {
+ }
+};
+
+BaseImpl::BaseImpl(const Event& event, sd_event_source* source,
+ std::false_type) :
+ Base(event, source, std::false_type())
+{
+ set_userdata(std::make_unique<BaseImplData>(*this));
+}
+
class BaseTest : public testing::Test
{
protected:
testing::StrictMock<test::SdEventMock> mock;
sd_event_source* const expected_source =
reinterpret_cast<sd_event_source*>(1234);
+ sd_event_source* const expected_source2 =
+ reinterpret_cast<sd_event_source*>(3456);
sd_event* const expected_event = reinterpret_cast<sd_event*>(2345);
+ sd_event* const expected_event2 = reinterpret_cast<sd_event*>(4567);
+
UniqueEvent event = make_event(expected_event);
UniqueEvent make_event(sd_event* event)
@@ -59,21 +86,30 @@
// Using a unique_ptr to make sure we don't get any superfluous moves or
// copies.
- std::unique_ptr<BaseImpl> make_base(const Event& event,
- sd_event_source* source)
+ std::tuple<std::unique_ptr<BaseImpl>, std::function<void()>>
+ make_base(const Event& event, sd_event_source* source)
{
EXPECT_CALL(mock, sd_event_ref(event.get()))
.WillOnce(Return(event.get()));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(
+ mock, sd_event_source_set_destroy_callback(source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock, sd_event_source_set_userdata(source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ }
auto ret = std::make_unique<BaseImpl>(event, source, std::false_type());
- EXPECT_EQ(ret.get(), userdata);
+ EXPECT_CALL(mock, sd_event_source_get_userdata(source))
+ .WillRepeatedly(Return(userdata));
+ EXPECT_NE(ret.get(), userdata);
EXPECT_EQ(source, ret->get());
EXPECT_NE(&event, &ret->get_event());
EXPECT_EQ(event.get(), ret->get_event().get());
EXPECT_FALSE(ret->get_prepare());
- return ret;
+ return {std::move(ret), std::bind(destroy, userdata)};
}
void set_prepare_placeholder(BaseImpl& base)
@@ -86,152 +122,107 @@
void empty_base(BaseImpl&& other)
{
- void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(other.get(), testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
BaseImpl mover(std::move(other));
- EXPECT_EQ(&mover, userdata);
EXPECT_THROW(other.get(), std::bad_optional_access);
EXPECT_THROW(other.get_event().get(), std::bad_optional_access);
- EXPECT_FALSE(other.get_prepare());
+ EXPECT_THROW(other.get_prepare(), std::bad_optional_access);
expect_base_destruct(mover.get_event(), mover.get());
}
void expect_base_destruct(const Event& event, sd_event_source* source)
{
- {
- testing::InSequence seq;
- EXPECT_CALL(mock, sd_event_source_set_enabled(source, SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(event.get()))
.WillOnce(Return(nullptr));
}
};
+TEST_F(BaseTest, NewBaseFail)
+{
+ EXPECT_CALL(mock, sd_event_ref(expected_event))
+ .WillOnce(Return(expected_event));
+ EXPECT_CALL(
+ mock, sd_event_source_set_destroy_callback(expected_source, testing::_))
+ .WillOnce(Return(-EINVAL));
+ expect_base_destruct(*event, expected_source);
+ EXPECT_THROW(BaseImpl(*event, expected_source, std::false_type()),
+ SdEventError);
+}
+
TEST_F(BaseTest, NewBaseNoRef)
{
EXPECT_CALL(mock, sd_event_ref(expected_event))
.WillOnce(Return(expected_event));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ }
BaseImpl source(*event, expected_source, std::false_type());
- EXPECT_EQ(&source, userdata);
+ EXPECT_NE(&source, userdata);
EXPECT_EQ(expected_source, source.get());
EXPECT_NE(event.get(), &source.get_event());
EXPECT_EQ(expected_event, source.get_event().get());
+
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillOnce(Return(userdata));
EXPECT_FALSE(source.get_prepare());
expect_base_destruct(*event, expected_source);
+ destroy(userdata);
}
-TEST_F(BaseTest, MoveConstruct)
+TEST_F(BaseTest, UserdataOutlives)
{
- std::unique_ptr<BaseImpl> source1 = make_base(*event, expected_source);
- set_prepare_placeholder(*source1);
-
+ EXPECT_CALL(mock, sd_event_ref(expected_event))
+ .WillOnce(Return(expected_event));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
- BaseImpl source2(std::move(*source1));
- EXPECT_EQ(&source2, userdata);
- EXPECT_THROW(source1->get(), std::bad_optional_access);
- EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
- EXPECT_FALSE(source1->get_prepare());
- EXPECT_EQ(expected_source, source2.get());
- EXPECT_EQ(expected_event, source2.get_event().get());
- EXPECT_TRUE(source2.get_prepare());
-
- expect_base_destruct(*event, expected_source);
-}
-
-TEST_F(BaseTest, MoveAssignSelf)
-{
- std::unique_ptr<BaseImpl> source1 = make_base(*event, expected_source);
- set_prepare_placeholder(*source1);
-
- *source1 = std::move(*source1);
- EXPECT_EQ(expected_source, source1->get());
- EXPECT_EQ(expected_event, source1->get_event().get());
- EXPECT_TRUE(source1->get_prepare());
-
- expect_base_destruct(*event, expected_source);
-}
-
-TEST_F(BaseTest, MoveAssignEmpty)
-{
- std::unique_ptr<BaseImpl> source1 = make_base(*event, expected_source);
- set_prepare_placeholder(*source1);
-
- std::unique_ptr<BaseImpl> source2 = make_base(*event, expected_source);
- empty_base(std::move(*source2));
-
{
- void* userdata;
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
EXPECT_CALL(mock,
sd_event_source_set_userdata(expected_source, testing::_))
.WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
- *source2 = std::move(*source1);
- EXPECT_EQ(source2.get(), userdata);
}
- EXPECT_THROW(source1->get(), std::bad_optional_access);
- EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
- EXPECT_FALSE(source1->get_prepare());
- EXPECT_EQ(expected_source, source2->get());
- EXPECT_EQ(expected_event, source2->get_event().get());
- EXPECT_TRUE(source2->get_prepare());
+ auto source =
+ std::make_unique<BaseImpl>(*event, expected_source, std::false_type());
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(Return(userdata));
+ EXPECT_FALSE(source->get_prepare());
- // Make sure source1 is deleted to ensure it isn't holding a reference
- source1.reset();
expect_base_destruct(*event, expected_source);
-}
-
-TEST_F(BaseTest, MoveAssignExisting)
-{
- sd_event_source* const expected_source2 =
- reinterpret_cast<sd_event_source*>(3456);
- sd_event* const expected_event2 = reinterpret_cast<sd_event*>(4567);
-
- std::unique_ptr<BaseImpl> source1 = make_base(*event, expected_source);
- set_prepare_placeholder(*source1);
-
- UniqueEvent event2 = make_event(expected_event2);
- std::unique_ptr<BaseImpl> source2 = make_base(*event2, expected_source2);
-
- {
- expect_base_destruct(*event2, expected_source2);
- void* userdata;
- EXPECT_CALL(mock,
- sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
- *source2 = std::move(*source1);
- EXPECT_EQ(source2.get(), userdata);
- }
- EXPECT_THROW(source1->get(), std::bad_optional_access);
- EXPECT_THROW(source1->get_event().get(), std::bad_optional_access);
- EXPECT_FALSE(source1->get_prepare());
- EXPECT_EQ(expected_source, source2->get());
- EXPECT_EQ(expected_event, source2->get_event().get());
- EXPECT_TRUE(source2->get_prepare());
-
- // Make sure source1 is deleted to ensure it isn't holding a reference
- source1.reset();
- expect_base_destruct(*event, expected_source);
+ source.reset();
+ EXPECT_FALSE(reinterpret_cast<BaseImpl*>(userdata)->get_prepare());
+ destroy(userdata);
}
class BaseMethodTest : public BaseTest
{
protected:
- std::unique_ptr<BaseImpl> base = make_base(*event, expected_source);
+ std::unique_ptr<BaseImpl> base;
+ std::function<void()> destroy;
+
+ void SetUp()
+ {
+ std::tie(base, destroy) = make_base(*event, expected_source);
+ }
void TearDown()
{
expect_base_destruct(base->get_event(), base->get());
base.reset();
+ destroy();
}
};
diff --git a/test/source/child.cpp b/test/source/child.cpp
index ab173b1..5dc06b9 100644
--- a/test/source/child.cpp
+++ b/test/source/child.cpp
@@ -21,6 +21,7 @@
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
@@ -47,14 +48,8 @@
void expect_destruct()
{
- {
- testing::InSequence sequence;
- EXPECT_CALL(mock, sd_event_source_set_enabled(expected_source,
- SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(expected_source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(expected_source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(expected_event))
.WillOnce(Return(nullptr));
}
@@ -72,9 +67,19 @@
options, testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<4>(&handler),
Return(0)));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
int completions = 0;
const siginfo_t* return_si;
Child::Callback callback = [&](Child&, const siginfo_t* si) {
@@ -83,19 +88,20 @@
};
Child child(*event, pid, options, std::move(callback));
EXPECT_FALSE(callback);
- EXPECT_EQ(&child, userdata);
+ EXPECT_NE(&child, userdata);
EXPECT_EQ(0, completions);
const siginfo_t* expected_si = reinterpret_cast<siginfo_t*>(865);
- EXPECT_EQ(0, handler(nullptr, expected_si, &child));
+ EXPECT_EQ(0, handler(nullptr, expected_si, userdata));
EXPECT_EQ(1, completions);
EXPECT_EQ(expected_si, return_si);
child.set_callback(std::bind([]() {}));
- EXPECT_EQ(0, handler(nullptr, expected_si, &child));
+ EXPECT_EQ(0, handler(nullptr, expected_si, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(ChildTest, ConstructError)
@@ -120,6 +126,8 @@
{
protected:
std::unique_ptr<Child> child;
+ sd_event_destroy_t destroy;
+ void* userdata;
void SetUp()
{
@@ -131,9 +139,17 @@
EXPECT_CALL(mock, sd_event_add_child(expected_event, testing::_, pid,
options, testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), Return(0)));
- EXPECT_CALL(mock,
- sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(Return(nullptr));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(
+ expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(
+ mock, sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
child = std::make_unique<Child>(*event, pid, options,
[](Child&, const siginfo_t*) {});
}
@@ -142,6 +158,7 @@
{
expect_destruct();
child.reset();
+ destroy(userdata);
}
};
diff --git a/test/source/event.cpp b/test/source/event.cpp
index e4d7b2a..1d5a877 100644
--- a/test/source/event.cpp
+++ b/test/source/event.cpp
@@ -20,6 +20,7 @@
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
@@ -46,14 +47,8 @@
void expect_destruct()
{
- {
- testing::InSequence sequence;
- EXPECT_CALL(mock, sd_event_source_set_enabled(expected_source,
- SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(expected_source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(expected_source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(expected_event))
.WillOnce(Return(nullptr));
}
@@ -63,9 +58,19 @@
{
EXPECT_CALL(mock, sd_event_ref(expected_event))
.WillOnce(Return(expected_event));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
sd_event_handler_t handler;
EXPECT_CALL(mock, sd_event_add_defer(expected_event, testing::_, testing::_,
nullptr))
@@ -76,27 +81,38 @@
completions++;
};
Defer defer(*event, std::move(callback));
- EXPECT_EQ(&defer, userdata);
+ EXPECT_NE(&defer, userdata);
EXPECT_FALSE(callback);
EXPECT_EQ(0, completions);
- EXPECT_EQ(0, handler(nullptr, &defer));
+ EXPECT_EQ(0, handler(nullptr, userdata));
EXPECT_EQ(1, completions);
defer.set_callback(std::bind([]() {}));
- EXPECT_EQ(0, handler(nullptr, &defer));
+ EXPECT_EQ(0, handler(nullptr, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(EventTest, PostConstruct)
{
EXPECT_CALL(mock, sd_event_ref(expected_event))
.WillOnce(Return(expected_event));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
sd_event_handler_t handler;
EXPECT_CALL(mock, sd_event_add_post(expected_event, testing::_, testing::_,
nullptr))
@@ -107,23 +123,34 @@
completions++;
};
Post post(*event, std::move(callback));
- EXPECT_EQ(&post, userdata);
+ EXPECT_NE(&post, userdata);
EXPECT_FALSE(callback);
EXPECT_EQ(0, completions);
- EXPECT_EQ(0, handler(nullptr, &post));
+ EXPECT_EQ(0, handler(nullptr, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(EventTest, ExitConstruct)
{
EXPECT_CALL(mock, sd_event_ref(expected_event))
.WillOnce(Return(expected_event));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
sd_event_handler_t handler;
EXPECT_CALL(mock, sd_event_add_exit(expected_event, testing::_, testing::_,
nullptr))
@@ -134,14 +161,15 @@
completions++;
};
Exit exit(*event, std::move(callback));
- EXPECT_EQ(&exit, userdata);
+ EXPECT_NE(&exit, userdata);
EXPECT_FALSE(callback);
EXPECT_EQ(0, completions);
- EXPECT_EQ(0, handler(nullptr, &exit));
+ EXPECT_EQ(0, handler(nullptr, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(EventTest, ConstructFailure)
diff --git a/test/source/io.cpp b/test/source/io.cpp
index 89506b1..bafdeb8 100644
--- a/test/source/io.cpp
+++ b/test/source/io.cpp
@@ -20,6 +20,7 @@
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
@@ -46,14 +47,8 @@
void expect_destruct()
{
- {
- testing::InSequence sequence;
- EXPECT_CALL(mock, sd_event_source_set_enabled(expected_source,
- SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(expected_source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(expected_source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(expected_event))
.WillOnce(Return(nullptr));
}
@@ -71,9 +66,19 @@
testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<4>(&handler),
Return(0)));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
int completions = 0;
int return_fd;
uint32_t return_revents;
@@ -84,19 +89,20 @@
};
IO io(*event, fd, events, std::move(callback));
EXPECT_FALSE(callback);
- EXPECT_EQ(&io, userdata);
+ EXPECT_NE(&io, userdata);
EXPECT_EQ(0, completions);
- EXPECT_EQ(0, handler(nullptr, 5, EPOLLIN, &io));
+ EXPECT_EQ(0, handler(nullptr, 5, EPOLLIN, userdata));
EXPECT_EQ(1, completions);
EXPECT_EQ(5, return_fd);
EXPECT_EQ(EPOLLIN, return_revents);
io.set_callback(std::bind([]() {}));
- EXPECT_EQ(0, handler(nullptr, 5, EPOLLIN, &io));
+ EXPECT_EQ(0, handler(nullptr, 5, EPOLLIN, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(IOTest, ConstructError)
@@ -120,6 +126,8 @@
{
protected:
std::unique_ptr<IO> io;
+ sd_event_destroy_t destroy;
+ void* userdata;
void SetUp()
{
@@ -131,9 +139,17 @@
EXPECT_CALL(mock, sd_event_add_io(expected_event, testing::_, fd,
events, testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), Return(0)));
- EXPECT_CALL(mock,
- sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(Return(nullptr));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(
+ expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(
+ mock, sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
io =
std::make_unique<IO>(*event, fd, events, [](IO&, int, uint32_t) {});
}
@@ -142,6 +158,7 @@
{
expect_destruct();
io.reset();
+ destroy(userdata);
}
};
diff --git a/test/source/signal.cpp b/test/source/signal.cpp
index d3b53a7..209f2a7 100644
--- a/test/source/signal.cpp
+++ b/test/source/signal.cpp
@@ -21,6 +21,7 @@
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
@@ -47,14 +48,8 @@
void expect_destruct()
{
- {
- testing::InSequence sequence;
- EXPECT_CALL(mock, sd_event_source_set_enabled(expected_source,
- SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(expected_source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(expected_source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(expected_event))
.WillOnce(Return(nullptr));
}
@@ -71,9 +66,19 @@
testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<3>(&handler),
Return(0)));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
int completions = 0;
const struct signalfd_siginfo* return_si;
Signal::Callback callback = [&](Signal&,
@@ -83,20 +88,21 @@
};
Signal signal(*event, sig, std::move(callback));
EXPECT_FALSE(callback);
- EXPECT_EQ(&signal, userdata);
+ EXPECT_NE(&signal, userdata);
EXPECT_EQ(0, completions);
const struct signalfd_siginfo* expected_si =
reinterpret_cast<struct signalfd_siginfo*>(865);
- EXPECT_EQ(0, handler(nullptr, expected_si, &signal));
+ EXPECT_EQ(0, handler(nullptr, expected_si, userdata));
EXPECT_EQ(1, completions);
EXPECT_EQ(expected_si, return_si);
signal.set_callback(std::bind([]() {}));
- EXPECT_EQ(0, handler(nullptr, expected_si, &signal));
+ EXPECT_EQ(0, handler(nullptr, expected_si, userdata));
EXPECT_EQ(1, completions);
expect_destruct();
+ destroy(userdata);
}
TEST_F(SignalTest, ConstructError)
@@ -120,6 +126,8 @@
{
protected:
std::unique_ptr<Signal> signal;
+ sd_event_destroy_t destroy;
+ void* userdata;
void SetUp()
{
@@ -130,9 +138,17 @@
EXPECT_CALL(mock, sd_event_add_signal(expected_event, testing::_, sig,
testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), Return(0)));
- EXPECT_CALL(mock,
- sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(Return(nullptr));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(
+ expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(
+ mock, sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
signal = std::make_unique<Signal>(
*event, sig, [](Signal&, const struct signalfd_siginfo*) {});
}
@@ -141,6 +157,7 @@
{
expect_destruct();
signal.reset();
+ destroy(userdata);
}
};
diff --git a/test/source/time.cpp b/test/source/time.cpp
index 96a920e..569d2c0 100644
--- a/test/source/time.cpp
+++ b/test/source/time.cpp
@@ -21,6 +21,7 @@
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
@@ -47,13 +48,8 @@
void expect_time_destroy(sd_event* event, sd_event_source* source)
{
- {
- testing::InSequence sequence;
- EXPECT_CALL(mock, sd_event_source_set_enabled(source, SD_EVENT_OFF))
- .WillOnce(Return(0));
- EXPECT_CALL(mock, sd_event_source_unref(source))
- .WillOnce(Return(nullptr));
- }
+ EXPECT_CALL(mock, sd_event_source_unref(source))
+ .WillOnce(Return(nullptr));
EXPECT_CALL(mock, sd_event_unref(event)).WillOnce(Return(nullptr));
}
};
@@ -77,12 +73,23 @@
2000000, 50000, testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<5>(&handler),
Return(0)));
+ sd_event_destroy_t destroy;
void* userdata;
- EXPECT_CALL(mock, sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(mock,
+ sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
Time<id> time(*event, expected_time, expected_accuracy,
std::move(callback));
EXPECT_FALSE(callback);
+ EXPECT_NE(&time, userdata);
EXPECT_EQ(expected_event, time.get_event().get());
EXPECT_EQ(expected_source, time.get());
@@ -96,6 +103,7 @@
saved_time);
expect_time_destroy(expected_event, expected_source);
+ destroy(userdata);
}
TEST_F(TimeTest, ConstructError)
@@ -120,6 +128,8 @@
protected:
static constexpr ClockId id = ClockId::BootTime;
std::unique_ptr<Time<id>> time;
+ sd_event_destroy_t destroy;
+ void* userdata;
void SetUp()
{
@@ -129,9 +139,17 @@
CLOCK_BOOTTIME, 2000000, 50000,
testing::_, nullptr))
.WillOnce(DoAll(SetArgPointee<1>(expected_source), Return(0)));
- EXPECT_CALL(mock,
- sd_event_source_set_userdata(expected_source, testing::_))
- .WillOnce(Return(nullptr));
+ {
+ testing::InSequence seq;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(
+ expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&destroy), Return(0)));
+ EXPECT_CALL(
+ mock, sd_event_source_set_userdata(expected_source, testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&userdata));
+ }
time = std::make_unique<Time<id>>(
*event, Time<id>::TimePoint(std::chrono::seconds{2}),
std::chrono::milliseconds{50},
@@ -142,6 +160,7 @@
{
expect_time_destroy(expected_event, expected_source);
time.reset();
+ destroy(userdata);
}
};
diff --git a/test/utility/timer.cpp b/test/utility/timer.cpp
index f35a0c4..70fda1b 100644
--- a/test/utility/timer.cpp
+++ b/test/utility/timer.cpp
@@ -23,6 +23,7 @@
using std::chrono::milliseconds;
using testing::DoAll;
using testing::Return;
+using testing::ReturnPointee;
using testing::SaveArg;
using testing::SetArgPointee;
using TestTimer = Timer<testClock>;
@@ -54,6 +55,7 @@
const milliseconds starting_time2{30};
sd_event_time_handler_t handler = nullptr;
void* handler_userdata;
+ sd_event_destroy_t handler_destroy;
std::unique_ptr<Event> event;
std::unique_ptr<TestTimer> timer;
std::function<void()> callback;
@@ -94,6 +96,7 @@
{
expectSetEnabled(source::Enabled::Off);
timer.reset();
+ handler_destroy(handler_userdata);
}
}
@@ -116,10 +119,15 @@
event = std::make_unique<Event>(expected_event, &mock);
EXPECT_CALL(mock, sd_event_source_unref(expected_source))
.WillRepeatedly(Return(nullptr));
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source,
+ testing::_))
+ .WillRepeatedly(DoAll(SaveArg<1>(&handler_destroy), Return(0)));
EXPECT_CALL(mock,
sd_event_source_set_userdata(expected_source, testing::_))
.WillRepeatedly(
DoAll(SaveArg<1>(&handler_userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source))
+ .WillRepeatedly(ReturnPointee(&handler_userdata));
// Having a callback proxy allows us to update the test callback
// dynamically, without changing it inside the timer
@@ -349,9 +357,16 @@
callback = [&]() { ++called; };
expectNow(starting_time2);
+ sd_event_destroy_t local_destroy;
+ EXPECT_CALL(mock, sd_event_source_set_destroy_callback(expected_source2,
+ testing::_))
+ .WillOnce(DoAll(SaveArg<1>(&local_destroy), Return(0)));
+ void* local_userdata;
EXPECT_CALL(mock,
sd_event_source_set_userdata(expected_source2, testing::_))
- .WillOnce(Return(nullptr));
+ .WillOnce(DoAll(SaveArg<1>(&local_userdata), Return(nullptr)));
+ EXPECT_CALL(mock, sd_event_source_get_userdata(expected_source2))
+ .WillRepeatedly(ReturnPointee(&local_userdata));
EXPECT_CALL(mock, sd_event_add_time(expected_event, testing::_,
static_cast<clockid_t>(testClock),
microseconds(starting_time2).count(),
@@ -368,6 +383,7 @@
// Move assign
local_timer = std::move(*timer);
+ local_destroy(local_userdata);
timer.reset();
// Move construct