public void EventBrokerCleanup(
            EventBroker eventBroker,
            WeakReference publisher,
            WeakReference registerablePublisher,
            WeakReference subscriber,
            WeakReference registerableSubscriber)
        {
            "Establish an event broker".x(() =>
                                          eventBroker = new EventBroker());

            "Establish a registered publisher".x(() =>
            {
                var p     = new SimpleEvent.EventPublisher();
                publisher = new WeakReference(p);
                eventBroker.Register(p);
            });

            "Establish a registered registerable publisher".x(() =>
            {
                var p = new SimpleEvent.RegisterableEventPublisher();
                registerablePublisher = new WeakReference(p);
                eventBroker.Register(p);
            });

            "Establish a registered subscriber".x(() =>
            {
                var s      = new SimpleEvent.EventSubscriber();
                subscriber = new WeakReference(s);
                eventBroker.Register(s);
            });

            "Establish a registered registerable subscriber".x(() =>
            {
                var s = new SimpleEvent.RegisterableEventSubscriber();
                registerableSubscriber = new WeakReference(s);
                eventBroker.Register(s);
            });

            "When enforcing the garbage collection".x(
                GC.Collect);

            "It should unregister publishers registered by attribute".x(() =>
                                                                        publisher.IsAlive
                                                                        .Should().BeFalse("publisher should not be referenced anymore"));

            "It should unregister publishers registered by registrar".x(() =>
                                                                        registerablePublisher.IsAlive
                                                                        .Should().BeFalse("publisher should not be referenced anymore"));

            "It should unregister subscribers registered by attribtue".x(() =>
                                                                         subscriber.IsAlive
                                                                         .Should().BeFalse("subscriber should not be referenced anymore"));

            "It should unregister subscribers registered by registrar".x(() =>
                                                                         registerableSubscriber.IsAlive
                                                                         .Should().BeFalse("subscriber should not be referenced anymore"));
        }
        public void PublisherCleanup(
            EventBroker eventBroker,
            SimpleEvent.EventPublisher publisher,
            SimpleEvent.RegisterableEventPublisher registerablePublisher,
            SimpleEvent.EventSubscriber subscriber,
            WeakReference weakReferenceOnPublisher,
            WeakReference weakReferenceOnRegisterablePublisher)
        {
            "Establish an event broker".x(() =>
                                          eventBroker = new EventBroker());

            "Establish a registered publisher".x(() =>
            {
                publisher = new SimpleEvent.EventPublisher();
                eventBroker.Register(publisher);
            });

            "Establish a registered registerable publisher".x(() =>
            {
                registerablePublisher = new SimpleEvent.RegisterableEventPublisher();
                eventBroker.Register(registerablePublisher);
            });

            "Establish a registered subscriber".x(() =>
            {
                subscriber = new SimpleEvent.EventSubscriber();
                eventBroker.Register(subscriber);
            });

            "Establish a weak references to the collected subscribers".x(() =>
            {
                weakReferenceOnPublisher             = new WeakReference(publisher);
                weakReferenceOnRegisterablePublisher = new WeakReference(registerablePublisher);
            });

            "When enforcing the garbage collection".x(() =>
            {
                publisher             = null;
                registerablePublisher = null;
                GC.Collect();
            });

            "It should garbage collect publisher registered by property".x(() =>
                                                                           weakReferenceOnPublisher.IsAlive
                                                                           .Should().BeFalse("publisher should be collected"));

            "It should garbage collect subscribers registered by registrar".x(() =>
                                                                              weakReferenceOnRegisterablePublisher.IsAlive
                                                                              .Should().BeFalse("publisher should be collected"));
        }