public void ShouldNotExecuteOnGarbageCollectedFilterReferenceWhenNotKeepAlive()
{
var pubSubEvent = new TestablePubSubEvent <string>();
var wasCalled = false;
var actionEvent = new ActionHelper
{
ActionToExecute = () => wasCalled = true
};
var filter = new ExternalFilter();
pubSubEvent.Subscribe(actionEvent.Action, ThreadOption.PublisherThread,
false, filter.AlwaysTrueFilter);
pubSubEvent.Publish("testPayload");
Assert.IsTrue(wasCalled);
wasCalled = false;
var filterReference = new WeakReference(filter);
filter = null;
GC.Collect();
Assert.IsFalse(filterReference.IsAlive);
pubSubEvent.Publish("testPayload");
Assert.IsFalse(wasCalled);
}
public async Task ShouldNotExecuteOnGarbageCollectedFilterReferenceWhenNotKeepAlive()
{
var PubSubEvent = new TestablePubSubEvent <string>();
bool wasCalled = false;
var actionEvent = new ActionHelper()
{
ActionToExecute = () => wasCalled = true
};
ExternalFilter filter = new ExternalFilter();
PubSubEvent.Subscribe(actionEvent.Action, ThreadOption.PublisherThread, false, filter.AlwaysTrueFilter);
PubSubEvent.Publish("testPayload");
Assert.True(wasCalled);
wasCalled = false;
WeakReference filterReference = new WeakReference(filter);
filter = null;
await Task.Delay(100);
GC.Collect();
Assert.False(filterReference.IsAlive);
PubSubEvent.Publish("testPayload");
Assert.False(wasCalled);
}
public void EnsureSubscriptionListIsEmptyAfterPublishingAMessage()
{
var pubSubEvent = new TestablePubSubEvent <string>();
SubscribeExternalActionWithoutReference(pubSubEvent);
GC.Collect();
pubSubEvent.Publish("testPayload");
Assert.True(pubSubEvent.BaseSubscriptions.Count == 0, "Subscriptionlist is not empty");
}
public void CanSubscribeAndRaiseEventNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
bool published = false;
pubSubEvent.Subscribe(delegate { published = true; }, ThreadOption.PublisherThread, true);
pubSubEvent.Publish();
Assert.IsTrue(published);
}
public void CanSubscribeAndRaiseEvent()
{
TestablePubSubEvent <string> pubSubEvent = new TestablePubSubEvent <string>();
bool published = false;
pubSubEvent.Subscribe(delegate { published = true; }, ThreadOption.PublisherThread, true, delegate { return(true); });
pubSubEvent.Publish(null);
Assert.IsTrue(published);
}
public void ShouldNotExecuteOnGarbageCollectedDelegateReferenceWhenNotKeepAlive()
{
var pubSubEvent = new TestablePubSubEvent <string>();
var externalAction = new ExternalAction();
pubSubEvent.Subscribe(externalAction.ExecuteAction);
pubSubEvent.Publish("testPayload");
Assert.AreEqual("testPayload", externalAction.PassedValue);
var actionEventReference = new WeakReference(externalAction);
externalAction = null;
GC.Collect();
Assert.IsFalse(actionEventReference.IsAlive);
pubSubEvent.Publish("testPayload");
}
public void ShouldNotExecuteOnGarbageCollectedDelegateReferenceWhenNotKeepAliveNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
var externalAction = new ExternalAction();
pubSubEvent.Subscribe(externalAction.ExecuteAction);
pubSubEvent.Publish();
Assert.IsTrue(externalAction.Executed);
var actionEventReference = new WeakReference(externalAction);
externalAction = null;
GC.Collect();
Assert.IsFalse(actionEventReference.IsAlive);
pubSubEvent.Publish();
}
public void SubscribeTakesExecuteDelegateThreadOptionAndFilter()
{
TestablePubSubEvent <string> pubSubEvent = new TestablePubSubEvent <string>();
var action = new ActionHelper();
pubSubEvent.Subscribe(action.Action);
pubSubEvent.Publish("test");
Assert.AreEqual("test", action.ActionArg <string>());
}
public void InlineDelegateDeclarationsDoesNotGetCollectedIncorrectlyWithWeakReferencesNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
bool published = false;
pubSubEvent.Subscribe(delegate { published = true; }, ThreadOption.PublisherThread, false);
GC.Collect();
pubSubEvent.Publish();
Assert.IsTrue(published);
}
public void InlineDelegateDeclarationsDoesNotGetCollectedIncorrectlyWithWeakReferences()
{
var PubSubEvent = new TestablePubSubEvent <string>();
bool published = false;
PubSubEvent.Subscribe(delegate { published = true; }, ThreadOption.PublisherThread, false, delegate { return(true); });
GC.Collect();
PubSubEvent.Publish(null);
Assert.IsTrue(published);
}
public void CanSubscribeAndRaiseCustomEvent()
{
var customEvent = new TestablePubSubEvent <Payload>();
Payload payload = new Payload();
var action = new ActionHelper();
customEvent.Subscribe(action.Action);
customEvent.Publish(payload);
Assert.AreSame(action.ActionArg <Payload>(), payload);
}
public async Task ShouldNotExecuteOnGarbageCollectedDelegateReferenceWhenNotKeepAlive()
{
var PubSubEvent = new TestablePubSubEvent <string>();
ExternalAction externalAction = new ExternalAction();
PubSubEvent.Subscribe(externalAction.ExecuteAction);
PubSubEvent.Publish("testPayload");
Assert.Equal("testPayload", externalAction.PassedValue);
WeakReference actionEventReference = new WeakReference(externalAction);
externalAction = null;
await Task.Delay(100);
GC.Collect();
Assert.False(actionEventReference.IsAlive);
PubSubEvent.Publish("testPayload");
}
public void ShouldUnsubscribeASingleDelegate()
{
var pubSubEvent = new TestablePubSubEvent <string>();
var callCount = 0;
var actionEvent = new ActionHelper
{
ActionToExecute = () => callCount++
};
pubSubEvent.Subscribe(actionEvent.Action);
pubSubEvent.Subscribe(actionEvent.Action);
pubSubEvent.Publish(null);
Assert.AreEqual(2, callCount);
callCount = 0;
pubSubEvent.Unsubscribe(actionEvent.Action);
pubSubEvent.Publish(null);
Assert.AreEqual(1, callCount);
}
public void ShouldUnsubscribeASingleDelegateNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
int callCount = 0;
var actionEvent = new ActionHelper()
{
ActionToExecute = () => callCount++
};
pubSubEvent.Subscribe(actionEvent.Action);
pubSubEvent.Subscribe(actionEvent.Action);
pubSubEvent.Publish();
Assert.AreEqual <int>(2, callCount);
callCount = 0;
pubSubEvent.Unsubscribe(actionEvent.Action);
pubSubEvent.Publish();
Assert.AreEqual <int>(1, callCount);
}
public void CanHaveMultipleSubscribersAndRaiseEvent()
{
var customEvent = new TestablePubSubEvent();
var action1 = new ActionHelper();
var action2 = new ActionHelper();
customEvent.Subscribe(action1.Action);
customEvent.Subscribe(action2.Action);
customEvent.Publish();
Assert.IsTrue(action1.ActionCalled);
Assert.IsTrue(action2.ActionCalled);
}
public void CanHaveMultipleSubscribersAndRaiseCustomEvent()
{
var customEvent = new TestablePubSubEvent <Payload>();
Payload payload = new Payload();
var action1 = new ActionHelper();
var action2 = new ActionHelper();
customEvent.Subscribe(action1.Action);
customEvent.Subscribe(action2.Action);
customEvent.Publish(payload);
Assert.Same(action1.ActionArg <Payload>(), payload);
Assert.Same(action2.ActionArg <Payload>(), payload);
}
public void CanAddSubscriptionWhileEventIsFiring()
{
var pubSubEvent = new TestablePubSubEvent <string>();
var emptyAction = new ActionHelper();
var subscriptionAction = new ActionHelper
{
ActionToExecute = () => pubSubEvent.Subscribe(emptyAction.Action)
};
pubSubEvent.Subscribe(subscriptionAction.Action);
Assert.IsFalse(pubSubEvent.Contains(emptyAction.Action));
pubSubEvent.Publish(null);
Assert.IsTrue(pubSubEvent.Contains(emptyAction.Action));
}
public void SubscribeDefaultsThreadOptionAndNoFilter()
{
var pubSubEvent = new TestablePubSubEvent <string>();
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
SynchronizationContext calledSyncContext = null;
var myAction = new ActionHelper
{
ActionToExecute =
() => calledSyncContext = SynchronizationContext.Current
};
pubSubEvent.Subscribe(myAction.Action);
pubSubEvent.Publish("test");
Assert.AreEqual(SynchronizationContext.Current, calledSyncContext);
}
public void ShouldNotGarbageCollectDelegateReferenceWhenUsingKeepAliveNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
var externalAction = new ExternalAction();
pubSubEvent.Subscribe(externalAction.ExecuteAction, ThreadOption.PublisherThread, true);
WeakReference actionEventReference = new WeakReference(externalAction);
externalAction = null;
GC.Collect();
GC.Collect();
Assert.IsTrue(actionEventReference.IsAlive);
pubSubEvent.Publish();
Assert.IsTrue(((ExternalAction)actionEventReference.Target).Executed);
}
public void ShouldNotGarbageCollectDelegateReferenceWhenUsingKeepAlive()
{
var pubSubEvent = new TestablePubSubEvent <string>();
var externalAction = new ExternalAction();
pubSubEvent.Subscribe(externalAction.ExecuteAction, ThreadOption.PublisherThread, true);
var actionEventReference = new WeakReference(externalAction);
externalAction = null;
GC.Collect();
GC.Collect();
Assert.IsTrue(actionEventReference.IsAlive);
pubSubEvent.Publish("testPayload");
Assert.AreEqual("testPayload", ((ExternalAction)actionEventReference.Target).PassedValue);
}
public void CanAddSubscriptionWhileEventIsFiringNonGeneric()
{
var pubSubEvent = new TestablePubSubEvent();
var emptyAction = new ActionHelper();
var subscriptionAction = new ActionHelper
{
ActionToExecute = (() =>
pubSubEvent.Subscribe(
emptyAction.Action))
};
pubSubEvent.Subscribe(subscriptionAction.Action);
Assert.False(pubSubEvent.Contains(emptyAction.Action));
pubSubEvent.Publish();
Assert.True((pubSubEvent.Contains(emptyAction.Action)));
}
public void FilterEnablesActionTarget()
{
TestablePubSubEvent <string> pubSubEvent = new TestablePubSubEvent <string>();
var goodFilter = new MockFilter {
FilterReturnValue = true
};
var actionGoodFilter = new ActionHelper();
var badFilter = new MockFilter {
FilterReturnValue = false
};
var actionBadFilter = new ActionHelper();
pubSubEvent.Subscribe(actionGoodFilter.Action, ThreadOption.PublisherThread, true, goodFilter.FilterString);
pubSubEvent.Subscribe(actionBadFilter.Action, ThreadOption.PublisherThread, true, badFilter.FilterString);
pubSubEvent.Publish("test");
Assert.IsTrue(actionGoodFilter.ActionCalled);
Assert.IsFalse(actionBadFilter.ActionCalled);
}
