public void CountSubscriptionsForIsCorrect()
{
var messenger = new MvxMessengerHub();
Assert.AreEqual(false, messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsFor <TestMessage>());
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.CountSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(0, messenger.CountSubscriptionsFor <TestMessage>());
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
});
Assert.AreEqual(1, messenger.CountSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(1, messenger.CountSubscriptionsFor <TestMessage>());
var token2 = messenger.Subscribe <TestMessage>(m =>
{
// stuff
});
Assert.AreEqual(1, messenger.CountSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(2, messenger.CountSubscriptionsFor <TestMessage>());
messenger.Unsubscribe <TestMessage>(token);
Assert.AreEqual(1, messenger.CountSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(1, messenger.CountSubscriptionsFor <TestMessage>());
messenger.Unsubscribe <TestMessage>(token2);
Assert.AreEqual(1, messenger.CountSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(0, messenger.CountSubscriptionsFor <TestMessage>());
}
public void HasSubscriptionsForTagIsCorrect()
{
var testTag = "TestTag";
var notExistingTag = "NotExistingTag";
var messenger = new MvxMessengerHub();
Assert.AreEqual(false, messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsFor <TestMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(notExistingTag));
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(true, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(notExistingTag));
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag);
Assert.AreEqual(true, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(true, messenger.HasSubscriptionsForTag <TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(notExistingTag));
messenger.Unsubscribe <TestMessage>(token);
Assert.AreEqual(true, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag <TestMessage>(notExistingTag));
}
public override void Initialize()
{
var connectionString = ConfigurationReader.GetConnectionString(Environment.Production);
var databaseName = GetDatabaseName(connectionString);
var task = Task.Run(async() => await ApplicationData.Current.LocalFolder.CreateFileAsync(databaseName, CreationCollisionOption.OpenIfExists)).Result;
var databasePath = Path.Combine(ApplicationData.Current.LocalFolder.Path, databaseName);
var customConnectionString = connectionString.Replace(databaseName, databasePath, StringComparison.CurrentCulture);
var connectionFactory = new ConnectionFactory(Environment.Production, customConnectionString);
var locationDao = new LocationDao(connectionFactory);
var skierDao = new SkierDao(connectionFactory);
var countryDao = new CountryDao(connectionFactory);
var raceDao = new RaceDao(connectionFactory);
var runDao = new RunDao(connectionFactory);
var sensorMeasurementDao = new SensorMeasurementDao(connectionFactory);
var daoProvider = new DaoProvider(countryDao, locationDao, raceDao, runDao, sensorMeasurementDao, skierDao);
var messengerHub = new MvxMessengerHub();
var simulatorRaceClock = new SimulatorRaceClock();
Mvx.IoCProvider.RegisterSingleton <IMvxMessenger>(messengerHub);
Mvx.IoCProvider.RegisterSingleton <IDialogService>(new DialogService(messengerHub));
Mvx.IoCProvider.RegisterSingleton <IRaceService>(new RaceService(daoProvider));
Mvx.IoCProvider.RegisterSingleton <ILocationService>(new LocationService(daoProvider));
Mvx.IoCProvider.RegisterSingleton <ISkierService>(new SkierService(daoProvider));
Mvx.IoCProvider.RegisterSingleton <IRunService>(new RunService(daoProvider, simulatorRaceClock));
Mvx.IoCProvider.RegisterSingleton <SimulatorRaceClock>(simulatorRaceClock);
RegisterAppStart <ViewModels.NavigationRootViewModel>();
}
public void GetSubscriptionTagsIsCorrect()
{
var testTag1 = "TestTag1";
var testTag2 = "TestTag2";
var messenger = new MvxMessengerHub();
Assert.IsEmpty(messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>());
Assert.IsEmpty(messenger.GetSubscriptionTagsFor <TestMessage>());
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.IsEmpty(messenger.GetSubscriptionTagsFor <TestMessage>());
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor <TestMessage>()[0]);
var token2 = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor <TestMessage>()[0]);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor <TestMessage>()[1]);
var token3 = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag2);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(3, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe <TestMessage>(token);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe <TestMessage>(token2);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
Assert.AreEqual(0, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe <TestMessage>(token3);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor <MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(0, messenger.GetSubscriptionTagsFor <TestMessage>().Count);
}
public void NullPublishCausesException()
{
var messenger = new MvxMessengerHub();
Assert.Throws <ArgumentNullException>(() => {
messenger.Publish <TestMessage>(null);
});
}
public static void ClassInitialize(TestContext textContext)
{
var fakeApplicationDataRepository = new FakeApplicationDataRepository();
var fakeMessenger = new MvxMessengerHub();
var applicationSettingService = new ApplicationSettingServiceSingleton(fakeApplicationDataRepository, fakeMessenger);
var applicationStorageService = new ApplicationStorageService(fakeApplicationDataRepository);
_myShuttleClient = new MyShuttleClient(applicationSettingService, applicationStorageService, fakeMessenger);
}
private void CreateShortLivedSubscription(MvxMessengerHub messenger)
{
// put a large byte array in place - this encourages the garbage collector to collect
var b = new byte[100000];
var action = new Action <TestMessage>((message) => { b[0] = 0; });
messenger.Subscribe <TestMessage>(action, MvxReference.Weak);
action = null;
}
protected override void AdditionalSetup()
{
_queueItems = new List <Core.Models.GatewayQueueItem>();
_mockQueueItemRepository = new Mock <Core.Repositories.IGatewayQueueItemRepository>();
_mockQueueItemRepository.Setup(m => m.GetAllInQueueOrderAsync()).ReturnsAsync(_queueItems);
_mockQueueItemRepository.Setup(m => m.InsertAsync(It.IsAny <Core.Models.GatewayQueueItem>()))
.Callback <Core.Models.GatewayQueueItem>(gqi => _queueItems.Add(gqi))
.Returns(Task.FromResult(0));
_mockQueueItemRepository.Setup(m => m.DeleteAsync(It.IsAny <Core.Models.GatewayQueueItem>()))
.Callback <Core.Models.GatewayQueueItem>(gqi => _queueItems.Remove(gqi))
.Returns(Task.FromResult(0));
_fixture = new Fixture().Customize(new AutoMoqCustomization());
IDeviceRepository repo = Mock.Of <IDeviceRepository>(dr => dr.GetAllAsync() == Task.FromResult(_fixture.CreateMany <Device>()));
IRepositories repos = Mock.Of <IRepositories>(r => r.DeviceRepository == repo &&
r.GatewayQueueItemRepository == _mockQueueItemRepository.Object);
_fixture.Register <IRepositories>(() => repos);
// Mock a success response from the BlueSphere MWF Mobile gateway service
var responseActions = new[] { new Core.Models.GatewayServiceResponse.ResponseAction {
Ack = true
} };
var response = new Core.HttpResult <Core.Models.GatewayServiceResponse.Response>
{
StatusCode = System.Net.HttpStatusCode.Accepted,
Content = new Core.Models.GatewayServiceResponse.Response {
Actions = responseActions
},
};
var mockHttpService = new Mock <Core.Services.IHttpService>();
mockHttpService.Setup(m => m.PostJsonAsync <Core.Models.GatewayServiceResponse.Response>(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(response);
_fixture.Register <Core.Services.IHttpService>(() => mockHttpService.Object);
_fixture.Register <Core.Services.IDeviceInfo>(() => Mock.Of <Core.Services.IDeviceInfo>());
var messenger = new MvxMessengerHub();
_fixture.Register <IMvxMessenger>(() => messenger);
// We don't have the GatewayQueueTimerService so replicate the trigger -> publish elapsed message functionality
_token = messenger.Subscribe <GatewayQueueTimerCommandMessage>(m =>
{
if (m.Command == GatewayQueueTimerCommandMessage.TimerCommand.Trigger)
{
messenger.Publish(new GatewayQueueTimerElapsedMessage(this));
}
});
}
public void DisposeTokenPreventsMessagesBeingReceived()
{
var messenger = new MvxMessengerHub();
Action <TestMessage> action = _ => Assert.That(false, "This event should not fire!");
var id = messenger.Subscribe(action);
id.Dispose();
messenger.Publish(new TestMessage(this));
}
public void UnsubscribePreventsMessagesBeingReceived()
{
var messenger = new MvxMessengerHub();
Action <TestMessage> action = _ => Assert.True(false, "This event should not fire!");
var id = messenger.Subscribe(action);
messenger.Unsubscribe <TestMessage>(id);
messenger.Publish(new TestMessage(this));
}
public void UnknownUnsubscribeDoesNotCauseException()
{
var messenger = new MvxMessengerHub();
messenger.Unsubscribe <TestMessage>(new MvxSubscriptionToken(Guid.NewGuid(), () => { }, new object()));
messenger.Subscribe <TestMessage>(m =>
{
// stuff
});
messenger.Unsubscribe <TestMessage>(new MvxSubscriptionToken(Guid.NewGuid(), () => { }, new object()));
messenger.Unsubscribe <TestMessage>(new MvxSubscriptionToken(Guid.Empty, () => { }, new object()));
}
public void SubscribeAndPublishAllowsMessageToBeReceived()
{
var messenger = new MvxMessengerHub();
var message = new TestMessage(this);
var messageReceived = false;
messenger.Subscribe<TestMessage>(m =>
{
Assert.That(m, Is.EqualTo(message));
Assert.That(m.Sender, Is.EqualTo(this));
messageReceived = true;
});
messenger.Publish(message);
Assert.IsTrue(messageReceived);
}
public void SubscribeAndPublishAllowsMessageToBeReceived()
{
var messenger = new MvxMessengerHub();
var message = new TestMessage(this);
var messageReceived = false;
messenger.Subscribe <TestMessage>(m =>
{
Assert.That(m, Is.EqualTo(message));
Assert.That(m.Sender, Is.EqualTo(this));
messageReceived = true;
});
messenger.Publish(message);
Assert.IsTrue(messageReceived);
}
public void MultipleSubscribeAndPublishAllowsMessageToBeReceived()
{
var messenger = new MvxMessengerHub();
var message = new TestMessage(this);
var otherMessage = new OtherTestMessage(this);
var messageReceived = 0;
messenger.Subscribe <TestMessage>(m =>
{
Assert.That(m, Is.EqualTo(message));
Assert.That(m.Sender, Is.EqualTo(this));
messageReceived++;
});
var otherMessageReceived = 0;
messenger.Subscribe <OtherTestMessage>(m =>
{
Assert.That(m, Is.EqualTo(otherMessage));
Assert.That(m.Sender, Is.EqualTo(this));
otherMessageReceived++;
});
messenger.Publish(otherMessage);
Assert.AreEqual(0, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(1, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(2, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(3, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(otherMessage);
Assert.AreEqual(3, messageReceived);
Assert.AreEqual(2, otherMessageReceived);
}
public void SetUp()
{
MvxSingleton.ClearAllSingletons();
ClearAll();
Dispatcher = new MockMvxViewDispatcher();
Ioc.RegisterSingleton <IMvxMainThreadDispatcher>(Dispatcher);
Ioc.RegisterSingleton <IMvxViewDispatcher>(Dispatcher);
DataClient = new MockCampDataClient();
Messenger = new MvxMessengerHub();
CodeCampService = new CodeCampService(new InMemoryFileManager(), new MvxJsonConverter(), DataClient);
ComposeEmailTask = new MockComposeEmailTask();
WebBrowserTask = new MockWebBrowserTask();
Mvx.RegisterSingleton <IMvxStringToTypeParser>(new MvxStringToTypeParser());
SetUpFixture();
}
public void AddProductTest()
{
var messenger = new MvxMessengerHub();
var stateService = new StateServiceTest();
var addProductViewModel =
new AddProductViewModel(messenger, stateService)
{
Name = "NewProduct",
Amount = "1"
};
addProductViewModel.SaveProductCommand.Execute();
var list = stateService.SelectedList;
Assert.AreEqual(1, list.Products.Count);
Assert.AreEqual("NewProduct", list.Products[0].Name);
Assert.AreEqual("1", list.Products[0].Amount);
}
public void SetUp()
{
MvxSingleton.ClearAllSingletons();
ClearAll();
Dispatcher = new MockMvxViewDispatcher();
Ioc.RegisterSingleton<IMvxMainThreadDispatcher>(Dispatcher);
Ioc.RegisterSingleton<IMvxViewDispatcher>(Dispatcher);
DataClient = new MockCampDataClient();
Messenger = new MvxMessengerHub();
CodeCampService = new CodeCampService(new InMemoryFileManager(), new MvxJsonConverter(), DataClient);
ComposeEmailTask = new MockComposeEmailTask();
WebBrowserTask = new MockWebBrowserTask();
Mvx.RegisterSingleton<IMvxStringToTypeParser>(new MvxStringToTypeParser());
SetUpFixture();
}
public void SubscribeAndUnsubscribeCauseChangeMessages()
{
var messenger = new MvxMessengerHub();
MvxSubscriberChangeMessage subscriberChangeMessage = null;
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => subscriberChangeMessage = message);
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
});
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(1, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
subscriberChangeMessage = null;
messenger.Unsubscribe <TestMessage>(token);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(0, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
}
public void MultipleSubscribeAndPublishAllowsMessageToBeReceived()
{
var messenger = new MvxMessengerHub();
var message = new TestMessage(this);
var otherMessage = new OtherTestMessage(this);
var messageReceived = 0;
messenger.Subscribe<TestMessage>(m =>
{
Assert.That(m, Is.EqualTo(message));
Assert.That(m.Sender, Is.EqualTo(this));
messageReceived++;
});
var otherMessageReceived = 0;
messenger.Subscribe<OtherTestMessage>(m =>
{
Assert.That(m, Is.EqualTo(otherMessage));
Assert.That(m.Sender, Is.EqualTo(this));
otherMessageReceived++;
});
messenger.Publish(otherMessage);
Assert.AreEqual(0, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(1, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(2, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(message);
Assert.AreEqual(3, messageReceived);
Assert.AreEqual(1, otherMessageReceived);
messenger.Publish(otherMessage);
Assert.AreEqual(3, messageReceived);
Assert.AreEqual(2, otherMessageReceived);
}
public void PurgeCausesChangeMessage()
{
var messenger = new MvxMessengerHub();
MvxSubscriberChangeMessage subscriberChangeMessage = null;
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => subscriberChangeMessage = message);
CreateShortLivedSubscription(messenger);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(1, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
subscriberChangeMessage = null;
System.Threading.Thread.Sleep(100);
GC.Collect();
GC.WaitForFullGCComplete();
messenger.Publish(new TestMessage(this));
System.Threading.Thread.Sleep(100);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(0, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
}
public virtual void SetUp()
{
this.ClearAll();
this._mockDispatcher = new MockDispatcher();
Ioc.RegisterSingleton <IMvxViewDispatcher>(this._mockDispatcher);
Ioc.RegisterSingleton <IMvxMainThreadDispatcher>(this._mockDispatcher);
Ioc.RegisterSingleton <IMvxTrace>(new TestTrace());
Ioc.RegisterSingleton <IMvxSettings>(new MvxSettings());
Ioc.RegisterSingleton <IMvxStringToTypeParser>(new MvxStringToTypeParser());
_messengerHub = new MvxMessengerHub();
Ioc.RegisterSingleton <IMvxMessenger>(_messengerHub);
_mockRepository = new MockRepository(MockBehavior.Default);
this.Initialize();
this.CreateTestableObject();
}
public void PurgeCausesChangeMessage()
{
var messenger = new MvxMessengerHub();
MvxSubscriberChangeMessage subscriberChangeMessage = null;
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => subscriberChangeMessage = message);
CreateShortLivedSubscription(messenger);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(1, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
subscriberChangeMessage = null;
Thread.Sleep(100);
GC.Collect();
GC.WaitForFullGCComplete();
messenger.Publish(new TestMessage(this));
Thread.Sleep(100);
// TODO - figure out why this test fails in NUnit console runner, but not through VS Test Execution
//Assert.NotNull(subscriberChangeMessage);
//Assert.AreEqual(0, subscriberChangeMessage.SubscriberCount);
//Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
}
public void HasSubscriptionsForIsCorrect()
{
var messenger = new MvxMessengerHub();
Assert.False(messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.False(messenger.HasSubscriptionsFor <TestMessage>());
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => { });
Assert.True(messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.False(messenger.HasSubscriptionsFor <TestMessage>());
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
});
Assert.True(messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.True(messenger.HasSubscriptionsFor <TestMessage>());
messenger.Unsubscribe <TestMessage>(token);
Assert.True(messenger.HasSubscriptionsFor <MvxSubscriberChangeMessage>());
Assert.False(messenger.HasSubscriptionsFor <TestMessage>());
}
private void CreateShortLivedSubscription(MvxMessengerHub messenger)
{
// put a large byte array in place - this encourages the garbage collector to collect
var b = new byte[100000];
var action = new Action<TestMessage>((message) => { b[0] = 0; });
messenger.Subscribe<TestMessage>(action, MvxReference.Weak);
action = null;
}
public void PurgeCausesChangeMessage()
{
var messenger = new MvxMessengerHub();
MvxSubscriberChangeMessage subscriberChangeMessage = null;
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => subscriberChangeMessage = message);
CreateShortLivedSubscription(messenger);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(1, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
subscriberChangeMessage = null;
System.Threading.Thread.Sleep(100);
GC.Collect();
GC.WaitForFullGCComplete();
messenger.Publish(new TestMessage(this));
System.Threading.Thread.Sleep(100);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(0, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
}
public void SubscribeAndUnsubscribeCauseChangeMessages()
{
var messenger = new MvxMessengerHub();
MvxSubscriberChangeMessage subscriberChangeMessage = null;
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => subscriberChangeMessage = message);
var token = messenger.Subscribe<TestMessage>(m =>
{
// stuff
});
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(1, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
subscriberChangeMessage = null;
messenger.Unsubscribe<TestMessage>(token);
Assert.NotNull(subscriberChangeMessage);
Assert.AreEqual(0, subscriberChangeMessage.SubscriberCount);
Assert.AreEqual(typeof(TestMessage), subscriberChangeMessage.MessageType);
}
public void GetSubscriptionTagsIsCorrect()
{
var testTag1 = "TestTag1";
var testTag2 = "TestTag2";
var messenger = new MvxMessengerHub();
Assert.IsEmpty(messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>());
Assert.IsEmpty(messenger.GetSubscriptionTagsFor<TestMessage>());
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.IsEmpty(messenger.GetSubscriptionTagsFor<TestMessage>());
var token = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor<TestMessage>()[0]);
var token2 = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor<TestMessage>()[0]);
Assert.AreEqual(testTag1, messenger.GetSubscriptionTagsFor<TestMessage>()[1]);
var token3 = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag: testTag2);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(3, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe<TestMessage>(token);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(2, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe<TestMessage>(token2);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
Assert.AreEqual(0, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag1).Count());
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<TestMessage>().Where(x => x == testTag2).Count());
messenger.Unsubscribe<TestMessage>(token3);
Assert.AreEqual(1, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>().Count);
Assert.AreEqual(null, messenger.GetSubscriptionTagsFor<MvxSubscriberChangeMessage>()[0]);
Assert.AreEqual(0, messenger.GetSubscriptionTagsFor<TestMessage>().Count);
}
public void CountSubscriptionsForTagIsCorrect()
{
var testTag1 = "TestTag1";
var testTag2 = "TestTag2";
var notExistingTag = "NotExistingTag";
var messenger = new MvxMessengerHub();
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
var token = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag:testTag1);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
var token2 = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag:testTag1);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(2, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
var token3 = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag: testTag2);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(2, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
messenger.Unsubscribe<TestMessage>(token);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
messenger.Unsubscribe<TestMessage>(token2);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
messenger.Unsubscribe<TestMessage>(token3);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag<TestMessage>(notExistingTag));
}
public void HasSubscriptionsForTagIsCorrect()
{
var testTag = "TestTag";
var notExistingTag = "NotExistingTag";
var messenger = new MvxMessengerHub();
Assert.AreEqual(false, messenger.HasSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsFor<TestMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(notExistingTag));
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(true, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(notExistingTag));
var token = messenger.Subscribe<TestMessage>(m =>
{
// stuff
}, tag: testTag);
Assert.AreEqual(true, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(true, messenger.HasSubscriptionsForTag<TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(notExistingTag));
messenger.Unsubscribe<TestMessage>(token);
Assert.AreEqual(true, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<MvxSubscriberChangeMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(testTag));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(null));
Assert.AreEqual(false, messenger.HasSubscriptionsForTag<TestMessage>(notExistingTag));
}
public void NullPublishCausesException()
{
var messenger = new MvxMessengerHub();
messenger.Publish<TestMessage>(null);
}
public void CountSubscriptionsForTagIsCorrect()
{
var testTag1 = "TestTag1";
var testTag2 = "TestTag2";
var notExistingTag = "NotExistingTag";
var messenger = new MvxMessengerHub();
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
var changeToken = messenger.Subscribe <MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
var token = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
var token2 = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag1);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(2, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
var token3 = messenger.Subscribe <TestMessage>(m =>
{
// stuff
}, tag: testTag2);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(2, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
messenger.Unsubscribe <TestMessage>(token);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
messenger.Unsubscribe <TestMessage>(token2);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
messenger.Unsubscribe <TestMessage>(token3);
Assert.AreEqual(1, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(null));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <MvxSubscriberChangeMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag1));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(testTag2));
Assert.AreEqual(0, messenger.CountSubscriptionsForTag <TestMessage>(notExistingTag));
}
public void NullSubscribeCausesException()
{
var messenger = new MvxMessengerHub();
messenger.Subscribe<TestMessage>(null);
}
public void DisposeTokenPreventsMessagesBeingReceived()
{
var messenger = new MvxMessengerHub();
Action<TestMessage> action = _ => Assert.That(false, "This event should not fire!");
var id = messenger.Subscribe(action);
id.Dispose();
messenger.Publish(new TestMessage(this));
}
public void NullPublishCausesException()
{
var messenger = new MvxMessengerHub();
Assert.Throws<ArgumentNullException>(() => {
messenger.Publish<TestMessage>(null);
});
}
public void NullSubscribeCausesException()
{
var messenger = new MvxMessengerHub();
messenger.Subscribe <TestMessage>(null);
}
public void CountSubscriptionsForIsCorrect()
{
var messenger = new MvxMessengerHub();
Assert.AreEqual(false, messenger.HasSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(false, messenger.HasSubscriptionsFor<TestMessage>());
var changeToken = messenger.Subscribe<MvxSubscriberChangeMessage>(message => { });
Assert.AreEqual(1, messenger.CountSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(0, messenger.CountSubscriptionsFor<TestMessage>());
var token = messenger.Subscribe<TestMessage>(m =>
{
// stuff
});
Assert.AreEqual(1, messenger.CountSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(1, messenger.CountSubscriptionsFor<TestMessage>());
var token2 = messenger.Subscribe<TestMessage>(m =>
{
// stuff
});
Assert.AreEqual(1, messenger.CountSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(2, messenger.CountSubscriptionsFor<TestMessage>());
messenger.Unsubscribe<TestMessage>(token);
Assert.AreEqual(1, messenger.CountSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(1, messenger.CountSubscriptionsFor<TestMessage>());
messenger.Unsubscribe<TestMessage>(token2);
Assert.AreEqual(1, messenger.CountSubscriptionsFor<MvxSubscriberChangeMessage>());
Assert.AreEqual(0, messenger.CountSubscriptionsFor<TestMessage>());
}
public void UnknownUnsubscribeDoesNotCauseException()
{
var messenger = new MvxMessengerHub();
messenger.Unsubscribe<TestMessage>(new MvxSubscriptionToken(Guid.NewGuid(), () => { }, new object()));
messenger.Subscribe<TestMessage>(m =>
{
// stuff
});
messenger.Unsubscribe<TestMessage>(new MvxSubscriptionToken(Guid.NewGuid(), () => { }, new object()));
messenger.Unsubscribe<TestMessage>(new MvxSubscriptionToken(Guid.Empty, () => { }, new object()));
}
public void NullPublishCausesException()
{
var messenger = new MvxMessengerHub();
messenger.Publish <TestMessage>(null);
}
