Vendor dependencies for 0.3.0 release

vendor/calloop/src/sources/mod.rs

@@ -0,0 +1,790 @@
+use std::{
+    cell::{Ref, RefCell, RefMut},
+    ops::{BitOr, BitOrAssign},
+    rc::Rc,
+};
+
+use log::trace;
+
+pub use crate::loop_logic::EventIterator;
+use crate::{sys::TokenFactory, Poll, Readiness, RegistrationToken, Token};
+
+pub mod channel;
+#[cfg(feature = "executor")]
+#[cfg_attr(docsrs, doc(cfg(feature = "executor")))]
+pub mod futures;
+pub mod generic;
+pub mod ping;
+#[cfg(all(target_os = "linux", feature = "signals"))]
+#[cfg_attr(docsrs, doc(cfg(target_os = "linux")))]
+pub mod signals;
+pub mod timer;
+pub mod transient;
+
+/// Possible actions that can be requested to the event loop by an
+/// event source once its events have been processed.
+///
+/// `PostAction` values can be combined with the `|` (bit-or) operator (or with
+/// `|=`) with the result that:
+/// - if both values are identical, the result is that value
+/// - if they are different, the result is [`Reregister`](PostAction::Reregister)
+///
+/// Bit-or-ing these results is useful for composed sources to combine the
+/// results of their child sources, but note that it only applies to the child
+/// sources. For example, if every child source returns `Continue`, the result
+/// will be `Continue`, but the parent source might still need to return
+/// `Reregister` or something else depending on any additional logic it uses.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum PostAction {
+    /// Continue listening for events on this source as before
+    Continue,
+    /// Trigger a re-registration of this source
+    Reregister,
+    /// Disable this source
+    ///
+    /// Has the same effect as [`LoopHandle::disable`](crate::LoopHandle#method.disable)
+    Disable,
+    /// Remove this source from the eventloop
+    ///
+    /// Has the same effect as [`LoopHandle::kill`](crate::LoopHandle#method.kill)
+    Remove,
+}
+
+/// Combines `PostAction` values returned from nested event sources.
+impl BitOr for PostAction {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        if matches!(self, x if x == rhs) {
+            self
+        } else {
+            Self::Reregister
+        }
+    }
+}
+
+/// Combines `PostAction` values returned from nested event sources.
+impl BitOrAssign for PostAction {
+    fn bitor_assign(&mut self, rhs: Self) {
+        if *self != rhs {
+            *self = Self::Reregister;
+        }
+    }
+}
+
+/// Trait representing an event source
+///
+/// This is the trait you need to implement if you wish to create your own
+/// calloop-compatible event sources.
+///
+/// The 3 associated types define the type of closure the user will need to
+/// provide to process events for your event source.
+///
+/// The `process_events` method will be called when one of the FD you registered
+/// is ready, with the associated readiness and token.
+///
+/// The `register`, `reregister` and `unregister` methods are plumbing to let your
+/// source register itself with the polling system. See their documentation for details.
+///
+/// In case your event source needs to do some special processing before or after a
+/// polling session occurs (to prepare the underlying source for polling, and cleanup
+/// after that), you can override [`NEEDS_EXTRA_LIFECYCLE_EVENTS`] to `true`.
+/// For all sources for which that constant is `true`, the methods [`before_sleep`] and
+/// [`before_handle_events`] will be called.
+/// [`before_sleep`] is called before the polling system performs a poll operation.
+/// [`before_handle_events`] is called before any process_events methods have been called.
+/// This means that during `process_events` you can assume that all cleanup has occured on
+/// all sources.
+///
+/// [`NEEDS_EXTRA_LIFECYCLE_EVENTS`]: EventSource::NEEDS_EXTRA_LIFECYCLE_EVENTS
+/// [`before_sleep`]: EventSource::before_sleep
+/// [`before_handle_events`]: EventSource::before_handle_events
+pub trait EventSource {
+    /// The type of events generated by your source.
+    type Event;
+    /// Some metadata of your event source
+    ///
+    /// This is typically useful if your source contains some internal state that
+    /// the user may need to interact with when processing events. The user callback
+    /// will receive a `&mut Metadata` reference.
+    ///
+    /// Set to `()` if not needed.
+    type Metadata;
+    /// The return type of the user callback
+    ///
+    /// If the user needs to return some value back to your event source once its
+    /// processing is finshed (to indicate success or failure for example), you can
+    /// specify it using this type.
+    ///
+    /// Set to `()` if not needed.
+    type Ret;
+    /// The error type returned from
+    /// [`process_events()`](Self::process_events()) (not the user callback!).
+    type Error: Into<Box<dyn std::error::Error + Sync + Send>>;
+
+    /// Process any relevant events
+    ///
+    /// This method will be called every time one of the FD you registered becomes
+    /// ready, including the readiness details and the associated token.
+    ///
+    /// Your event source will then do some processing of the file descriptor(s) to generate
+    /// events, and call the provided `callback` for each one of them.
+    ///
+    /// You should ensure you drained the file descriptors of their events, especially if using
+    /// edge-triggered mode.
+    fn process_events<F>(
+        &mut self,
+        readiness: Readiness,
+        token: Token,
+        callback: F,
+    ) -> Result<PostAction, Self::Error>
+    where
+        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret;
+
+    /// Register yourself to this poll instance
+    ///
+    /// You should register all your relevant file descriptors to the provided [`Poll`](crate::Poll)
+    /// using its [`Poll::register`](crate::Poll#method.register) method.
+    ///
+    /// If you need to register more than one file descriptor, you can change the
+    /// `sub_id` field of the [`Token`](crate::Token) to differentiate between them.
+    fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()>;
+
+    /// Re-register your file descriptors
+    ///
+    /// Your should update the registration of all your relevant file descriptor to
+    /// the provided [`Poll`](crate::Poll) using its [`Poll::reregister`](crate::Poll#method.reregister),
+    /// if necessary.
+    fn reregister(
+        &mut self,
+        poll: &mut Poll,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<()>;
+
+    /// Unregister your file descriptors
+    ///
+    /// You should unregister all your file descriptors from this [`Poll`](crate::Poll) using its
+    /// [`Poll::unregister`](crate::Poll#method.unregister) method.
+    fn unregister(&mut self, poll: &mut Poll) -> crate::Result<()>;
+
+    /// Whether this source needs to be sent the [`EventSource::before_sleep`]
+    /// and [`EventSource::before_handle_events`] notifications. These are opt-in because
+    /// they require more expensive checks, and almost all sources will not need these notifications
+    const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = false;
+    /// Notification that a single `poll` is about to begin
+    ///
+    /// Use this to perform operations which must be done before polling,
+    /// but which may conflict with other event handlers. For example,
+    /// if polling requires a lock to be taken
+    ///
+    /// If this returns Ok(Some), this will be treated as an event arriving in polling, and
+    /// your event handler will be called with the returned `Token` and `Readiness`.
+    /// Polling will however still occur, but with a timeout of 0, so additional events
+    /// from this or other sources may also be handled in the same iterations.
+    /// The returned `Token` must belong to this source
+    // If you need to return multiple synthetic events from this notification, please
+    // open an issue
+    fn before_sleep(&mut self) -> crate::Result<Option<(Readiness, Token)>> {
+        Ok(None)
+    }
+    /// Notification that polling is complete, and [`EventSource::process_events`] will
+    /// be called with the given events for this source. The iterator may be empty,
+    /// which indicates that no events were generated for this source
+    ///
+    /// Please note, the iterator excludes any synthetic events returned from
+    /// [`EventSource::before_sleep`]
+    ///
+    /// Use this to perform a cleanup before event handlers with arbitrary
+    /// code may run. This could be used to drop a lock obtained in
+    /// [`EventSource::before_sleep`]
+    #[allow(unused_variables)]
+    fn before_handle_events(&mut self, events: EventIterator<'_>) {}
+}
+
+/// Blanket implementation for boxed event sources. [`EventSource`] is not an
+/// object safe trait, so this does not include trait objects.
+impl<T: EventSource> EventSource for Box<T> {
+    type Event = T::Event;
+    type Metadata = T::Metadata;
+    type Ret = T::Ret;
+    type Error = T::Error;
+
+    fn process_events<F>(
+        &mut self,
+        readiness: Readiness,
+        token: Token,
+        callback: F,
+    ) -> Result<PostAction, Self::Error>
+    where
+        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
+    {
+        T::process_events(&mut **self, readiness, token, callback)
+    }
+
+    fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()> {
+        T::register(&mut **self, poll, token_factory)
+    }
+
+    fn reregister(
+        &mut self,
+        poll: &mut Poll,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<()> {
+        T::reregister(&mut **self, poll, token_factory)
+    }
+
+    fn unregister(&mut self, poll: &mut Poll) -> crate::Result<()> {
+        T::unregister(&mut **self, poll)
+    }
+
+    const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = T::NEEDS_EXTRA_LIFECYCLE_EVENTS;
+
+    fn before_sleep(&mut self) -> crate::Result<Option<(Readiness, Token)>> {
+        T::before_sleep(&mut **self)
+    }
+
+    fn before_handle_events(&mut self, events: EventIterator) {
+        T::before_handle_events(&mut **self, events)
+    }
+}
+
+/// Blanket implementation for exclusive references to event sources.
+/// [`EventSource`] is not an object safe trait, so this does not include trait
+/// objects.
+impl<T: EventSource> EventSource for &mut T {
+    type Event = T::Event;
+    type Metadata = T::Metadata;
+    type Ret = T::Ret;
+    type Error = T::Error;
+
+    fn process_events<F>(
+        &mut self,
+        readiness: Readiness,
+        token: Token,
+        callback: F,
+    ) -> Result<PostAction, Self::Error>
+    where
+        F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
+    {
+        T::process_events(&mut **self, readiness, token, callback)
+    }
+
+    fn register(&mut self, poll: &mut Poll, token_factory: &mut TokenFactory) -> crate::Result<()> {
+        T::register(&mut **self, poll, token_factory)
+    }
+
+    fn reregister(
+        &mut self,
+        poll: &mut Poll,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<()> {
+        T::reregister(&mut **self, poll, token_factory)
+    }
+
+    fn unregister(&mut self, poll: &mut Poll) -> crate::Result<()> {
+        T::unregister(&mut **self, poll)
+    }
+
+    const NEEDS_EXTRA_LIFECYCLE_EVENTS: bool = T::NEEDS_EXTRA_LIFECYCLE_EVENTS;
+
+    fn before_sleep(&mut self) -> crate::Result<Option<(Readiness, Token)>> {
+        T::before_sleep(&mut **self)
+    }
+
+    fn before_handle_events(&mut self, events: EventIterator) {
+        T::before_handle_events(&mut **self, events)
+    }
+}
+
+pub(crate) struct DispatcherInner<S, F> {
+    source: S,
+    callback: F,
+    needs_additional_lifecycle_events: bool,
+}
+
+impl<Data, S, F> EventDispatcher<Data> for RefCell<DispatcherInner<S, F>>
+where
+    S: EventSource,
+    F: FnMut(S::Event, &mut S::Metadata, &mut Data) -> S::Ret,
+{
+    fn process_events(
+        &self,
+        readiness: Readiness,
+        token: Token,
+        data: &mut Data,
+    ) -> crate::Result<PostAction> {
+        let mut disp = self.borrow_mut();
+        let DispatcherInner {
+            ref mut source,
+            ref mut callback,
+            ..
+        } = *disp;
+        trace!(
+            "[calloop] Processing events for source type {}",
+            std::any::type_name::<S>()
+        );
+        source
+            .process_events(readiness, token, |event, meta| callback(event, meta, data))
+            .map_err(|e| crate::Error::OtherError(e.into()))
+    }
+
+    fn register(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<()> {
+        let mut this = self.borrow_mut();
+
+        if this.needs_additional_lifecycle_events {
+            additional_lifecycle_register.register(token_factory.registration_token());
+        }
+        this.source.register(poll, token_factory)
+    }
+
+    fn reregister(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<bool> {
+        if let Ok(mut me) = self.try_borrow_mut() {
+            me.source.reregister(poll, token_factory)?;
+            if me.needs_additional_lifecycle_events {
+                additional_lifecycle_register.register(token_factory.registration_token());
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn unregister(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        registration_token: RegistrationToken,
+    ) -> crate::Result<bool> {
+        if let Ok(mut me) = self.try_borrow_mut() {
+            me.source.unregister(poll)?;
+            if me.needs_additional_lifecycle_events {
+                additional_lifecycle_register.unregister(registration_token);
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn before_sleep(&self) -> crate::Result<Option<(Readiness, Token)>> {
+        let mut disp = self.borrow_mut();
+        let DispatcherInner { ref mut source, .. } = *disp;
+        source.before_sleep()
+    }
+
+    fn before_handle_events(&self, events: EventIterator<'_>) {
+        let mut disp = self.borrow_mut();
+        let DispatcherInner { ref mut source, .. } = *disp;
+        source.before_handle_events(events);
+    }
+}
+
+pub(crate) trait EventDispatcher<Data> {
+    fn process_events(
+        &self,
+        readiness: Readiness,
+        token: Token,
+        data: &mut Data,
+    ) -> crate::Result<PostAction>;
+
+    fn register(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<()>;
+
+    fn reregister(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        token_factory: &mut TokenFactory,
+    ) -> crate::Result<bool>;
+
+    fn unregister(
+        &self,
+        poll: &mut Poll,
+        additional_lifecycle_register: &mut AdditionalLifecycleEventsSet,
+        registration_token: RegistrationToken,
+    ) -> crate::Result<bool>;
+
+    fn before_sleep(&self) -> crate::Result<Option<(Readiness, Token)>>;
+    fn before_handle_events(&self, events: EventIterator<'_>);
+}
+
+#[derive(Default)]
+/// The list of events
+pub(crate) struct AdditionalLifecycleEventsSet {
+    /// The list of sources
+    pub(crate) values: Vec<RegistrationToken>,
+}
+
+impl AdditionalLifecycleEventsSet {
+    fn register(&mut self, token: RegistrationToken) {
+        self.values.push(token)
+    }
+
+    fn unregister(&mut self, token: RegistrationToken) {
+        self.values.retain(|it| it != &token)
+    }
+}
+
+// An internal trait to erase the `F` type parameter of `DispatcherInner`
+trait ErasedDispatcher<'a, S, Data> {
+    fn as_source_ref(&self) -> Ref<S>;
+    fn as_source_mut(&self) -> RefMut<S>;
+    fn into_source_inner(self: Rc<Self>) -> S;
+    fn into_event_dispatcher(self: Rc<Self>) -> Rc<dyn EventDispatcher<Data> + 'a>;
+}
+
+impl<'a, S, Data, F> ErasedDispatcher<'a, S, Data> for RefCell<DispatcherInner<S, F>>
+where
+    S: EventSource + 'a,
+    F: FnMut(S::Event, &mut S::Metadata, &mut Data) -> S::Ret + 'a,
+{
+    fn as_source_ref(&self) -> Ref<S> {
+        Ref::map(self.borrow(), |inner| &inner.source)
+    }
+
+    fn as_source_mut(&self) -> RefMut<S> {
+        RefMut::map(self.borrow_mut(), |inner| &mut inner.source)
+    }
+
+    fn into_source_inner(self: Rc<Self>) -> S {
+        if let Ok(ref_cell) = Rc::try_unwrap(self) {
+            ref_cell.into_inner().source
+        } else {
+            panic!("Dispatcher is still registered");
+        }
+    }
+
+    fn into_event_dispatcher(self: Rc<Self>) -> Rc<dyn EventDispatcher<Data> + 'a>
+    where
+        S: 'a,
+    {
+        self as Rc<dyn EventDispatcher<Data> + 'a>
+    }
+}
+
+/// An event source with its callback.
+///
+/// The `Dispatcher` can be registered in an event loop.
+/// Use the `as_source_{ref,mut}` functions to interact with the event source.
+/// Use `into_source_inner` to get the event source back.
+pub struct Dispatcher<'a, S, Data>(Rc<dyn ErasedDispatcher<'a, S, Data> + 'a>);
+
+impl<'a, S, Data> std::fmt::Debug for Dispatcher<'a, S, Data> {
+    #[cfg_attr(feature = "nightly_coverage", coverage(off))]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Dispatcher { ... }")
+    }
+}
+
+impl<'a, S, Data> Dispatcher<'a, S, Data>
+where
+    S: EventSource + 'a,
+{
+    /// Builds a dispatcher.
+    ///
+    /// The resulting `Dispatcher`
+    pub fn new<F>(source: S, callback: F) -> Self
+    where
+        F: FnMut(S::Event, &mut S::Metadata, &mut Data) -> S::Ret + 'a,
+    {
+        Dispatcher(Rc::new(RefCell::new(DispatcherInner {
+            source,
+            callback,
+            needs_additional_lifecycle_events: S::NEEDS_EXTRA_LIFECYCLE_EVENTS,
+        })))
+    }
+
+    /// Returns an immutable reference to the event source.
+    ///
+    /// # Panics
+    ///
+    /// Has the same semantics as `RefCell::borrow()`.
+    ///
+    /// The dispatcher being mutably borrowed while its events are dispatched,
+    /// this method will panic if invoked from within the associated dispatching closure.
+    pub fn as_source_ref(&self) -> Ref<S> {
+        self.0.as_source_ref()
+    }
+
+    /// Returns a mutable reference to the event source.
+    ///
+    /// # Panics
+    ///
+    /// Has the same semantics as `RefCell::borrow_mut()`.
+    ///
+    /// The dispatcher being mutably borrowed while its events are dispatched,
+    /// this method will panic if invoked from within the associated dispatching closure.
+    pub fn as_source_mut(&self) -> RefMut<S> {
+        self.0.as_source_mut()
+    }
+
+    /// Consumes the Dispatcher and returns the inner event source.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `Dispatcher` is still registered.
+    pub fn into_source_inner(self) -> S {
+        self.0.into_source_inner()
+    }
+
+    pub(crate) fn clone_as_event_dispatcher(&self) -> Rc<dyn EventDispatcher<Data> + 'a> {
+        Rc::clone(&self.0).into_event_dispatcher()
+    }
+}
+
+impl<'a, S, Data> Clone for Dispatcher<'a, S, Data> {
+    fn clone(&self) -> Dispatcher<'a, S, Data> {
+        Dispatcher(Rc::clone(&self.0))
+    }
+}
+
+/// An idle callback that was inserted in this loop
+///
+/// This handle allows you to cancel the callback. Dropping
+/// it will *not* cancel it.
+pub struct Idle<'i> {
+    pub(crate) callback: Rc<RefCell<dyn CancellableIdle + 'i>>,
+}
+
+impl<'i> std::fmt::Debug for Idle<'i> {
+    #[cfg_attr(feature = "nightly_coverage", coverage(off))]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Idle { ... }")
+    }
+}
+
+impl<'i> Idle<'i> {
+    /// Cancel the idle callback if it was not already run
+    pub fn cancel(self) {
+        self.callback.borrow_mut().cancel();
+    }
+}
+
+pub(crate) trait CancellableIdle {
+    fn cancel(&mut self);
+}
+
+impl<F> CancellableIdle for Option<F> {
+    fn cancel(&mut self) {
+        self.take();
+    }
+}
+
+pub(crate) trait IdleDispatcher<Data> {
+    fn dispatch(&mut self, data: &mut Data);
+}
+
+impl<Data, F> IdleDispatcher<Data> for Option<F>
+where
+    F: FnMut(&mut Data),
+{
+    fn dispatch(&mut self, data: &mut Data) {
+        if let Some(callabck) = self.as_mut() {
+            callabck(data);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use crate::{ping::make_ping, EventLoop};
+
+    // Test event source boxing.
+    #[test]
+    fn test_boxed_source() {
+        let mut fired = false;
+
+        let (pinger, source) = make_ping().unwrap();
+        let boxed = Box::new(source);
+
+        let mut event_loop = EventLoop::try_new().unwrap();
+        let handle = event_loop.handle();
+
+        let token = handle
+            .insert_source(boxed, |_, _, fired| *fired = true)
+            .unwrap();
+
+        pinger.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(fired);
+        fired = false;
+
+        handle.update(&token).unwrap();
+
+        pinger.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(fired);
+        fired = false;
+
+        handle.remove(token);
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(!fired);
+    }
+
+    // Test event source trait methods via mut ref.
+    #[test]
+    fn test_mut_ref_source() {
+        let mut fired = false;
+
+        let (pinger, mut source) = make_ping().unwrap();
+        let source_ref = &mut source;
+
+        let mut event_loop = EventLoop::try_new().unwrap();
+        let handle = event_loop.handle();
+
+        let token = handle
+            .insert_source(source_ref, |_, _, fired| *fired = true)
+            .unwrap();
+
+        pinger.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(fired);
+        fired = false;
+
+        handle.update(&token).unwrap();
+
+        pinger.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(fired);
+        fired = false;
+
+        handle.remove(token);
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert!(!fired);
+    }
+
+    // Test PostAction combinations.
+    #[test]
+    fn post_action_combine() {
+        use super::PostAction::*;
+        assert_eq!(Continue | Continue, Continue);
+        assert_eq!(Continue | Reregister, Reregister);
+        assert_eq!(Continue | Disable, Reregister);
+        assert_eq!(Continue | Remove, Reregister);
+
+        assert_eq!(Reregister | Continue, Reregister);
+        assert_eq!(Reregister | Reregister, Reregister);
+        assert_eq!(Reregister | Disable, Reregister);
+        assert_eq!(Reregister | Remove, Reregister);
+
+        assert_eq!(Disable | Continue, Reregister);
+        assert_eq!(Disable | Reregister, Reregister);
+        assert_eq!(Disable | Disable, Disable);
+        assert_eq!(Disable | Remove, Reregister);
+
+        assert_eq!(Remove | Continue, Reregister);
+        assert_eq!(Remove | Reregister, Reregister);
+        assert_eq!(Remove | Disable, Reregister);
+        assert_eq!(Remove | Remove, Remove);
+    }
+
+    // Test PostAction self-assignment.
+    #[test]
+    fn post_action_combine_assign() {
+        use super::PostAction::*;
+
+        let mut action = Continue;
+        action |= Continue;
+        assert_eq!(action, Continue);
+
+        let mut action = Continue;
+        action |= Reregister;
+        assert_eq!(action, Reregister);
+
+        let mut action = Continue;
+        action |= Disable;
+        assert_eq!(action, Reregister);
+
+        let mut action = Continue;
+        action |= Remove;
+        assert_eq!(action, Reregister);
+
+        let mut action = Reregister;
+        action |= Continue;
+        assert_eq!(action, Reregister);
+
+        let mut action = Reregister;
+        action |= Reregister;
+        assert_eq!(action, Reregister);
+
+        let mut action = Reregister;
+        action |= Disable;
+        assert_eq!(action, Reregister);
+
+        let mut action = Reregister;
+        action |= Remove;
+        assert_eq!(action, Reregister);
+
+        let mut action = Disable;
+        action |= Continue;
+        assert_eq!(action, Reregister);
+
+        let mut action = Disable;
+        action |= Reregister;
+        assert_eq!(action, Reregister);
+
+        let mut action = Disable;
+        action |= Disable;
+        assert_eq!(action, Disable);
+
+        let mut action = Disable;
+        action |= Remove;
+        assert_eq!(action, Reregister);
+
+        let mut action = Remove;
+        action |= Continue;
+        assert_eq!(action, Reregister);
+
+        let mut action = Remove;
+        action |= Reregister;
+        assert_eq!(action, Reregister);
+
+        let mut action = Remove;
+        action |= Disable;
+        assert_eq!(action, Reregister);
+
+        let mut action = Remove;
+        action |= Remove;
+        assert_eq!(action, Remove);
+    }
+}