public void ShouldForwardPolymorphicMessage()
 {
     var handler = new TestEventHandler();
     var message = new TestMessage();
     EventFns.Forward(handler, message);
     Assert.IsTrue(handler.IMessageHandled, "Message should have been handled");
 }

        public void ServiceQueue_1_Writer_1_Reader(ServiceQueueRotationAlgorithm algorithm)
        {
            using (var serviceQueue = new ServiceQueue(algorithm))
            using (var reader = new ServiceQueueReader())
            using (var writer = new ServiceQueueWriter())
            {
                var endpoint = GetEndpoint();
                serviceQueue.Bind(endpoint);

                var counterSignal = new CounterSignal(NumberOfMessages, 0);
                reader.MessageReceived += (s, m) => counterSignal.Increment();

                reader.Connect(endpoint);
                writer.Connect(endpoint);

                var messageSent = new TestMessage();

                var sw = Stopwatch.StartNew();
                for (var i = 0; i < NumberOfMessages; i++)
                {
                    writer.SendMessage(messageSent);
                }
                Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
                sw.Stop();

                Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessages, NumberOfMessages / sw.Elapsed.TotalSeconds);

            }
        }

        public void SerialiseMessageWithGuid()
        {
            var message = new TestMessage { Id = Guid.Parse("C50DDB56-B827-46E3-9D7D-ACB701882624") };
             var serialisedMessage = this.componentUnderTest.Serialise(message);

             Assert.That(serialisedMessage, Is.EqualTo(MessageWithGuid));
        }

		public void Should_properly_arrive_at_the_destination()
		{
			var serviceUri = new Uri("net.pipe://localhost/pipe");
			string pipeName = "test";

			var future = new Future<TestMessage>();
			var message = new TestMessage
				{
					Id = Guid.NewGuid(),
					Name = "Alpha",
				};

			UntypedChannel adapter = new ChannelAdapter();
			using (var remote = new WcfChannelHost(new SynchronousFiber(), adapter, serviceUri, pipeName))
			{
				using (adapter.Connect(x =>
					{
						x.AddConsumerOf<TestMessage>()
							.UsingConsumer(m => future.Complete(m));
					}))
				{
					var client = new WcfChannelProxy(new SynchronousFiber(), serviceUri, pipeName);

					client.Send(message);

					future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
				}
			}

			future.Value.ShouldNotBeNull();
			future.Value.ShouldEqual(message);
			future.Value.ShouldNotBeTheSameAs(message);
		}

        public void One_Publisher_One_Subscriber_Batch_Broadcast()
        {
            using (var publisher = new Publisher())
            using (var subscriber = new Subscriber())
            {
                var endpoint = GetEndpoint();
                publisher.Bind(endpoint);
                subscriber.Connect(endpoint);

                Thread.Sleep(100);

                var counterSignal = new CounterSignal(NumberOfMessagesToReceive);
                subscriber.MessageReceived += (s, m) => counterSignal.Increment();

                var messageSent = new TestMessage();

                var batch = new List<TestMessage>();
                for (var i = 0; i < NumberOfMessagesToReceive; i++)
                    batch.Add(messageSent);

                var sw = Stopwatch.StartNew();
                publisher.Broadcast(batch);
                Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
                sw.Stop();

                Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessagesToReceive, NumberOfMessagesToReceive / sw.Elapsed.TotalSeconds);
            }
        }

        public void SetsTheValueOfTheMessageProperty()
        {
            var message = new TestMessage();

            var routeResult = new RouteResult(message, null);

            Assert.That(routeResult.Message, Is.SameAs(message));
        }

 public void GetInstance_NullInstanceContext()
 {
     var data = new ServiceImplementationData();
     var container = new ContainerBuilder().Build();
     var provider = new AutofacInstanceProvider(container, data);
     var message = new TestMessage();
     Assert.Throws<ArgumentNullException>(() => provider.GetInstance(null, message));
 }

		public void send_waiting_message_fires_event_hooks ()
		{
			var msg = new TestMessage();
			((SenderNode)_subject).SendMessage(msg);

			_eventHook1.Received().MessageSent(msg);
			_eventHook2.Received().MessageSent(msg);
		}

 public void TestBroker()
 {
     TestMessage message = new TestMessage {Id = Guid.NewGuid(), Text = "Some text"};
     MessageBroker broker = new MessageBroker();
     broker.Write(message);
     TestMessage readMessage = broker.Read<TestMessage>(0);
     Assert.IsNotNull(readMessage);
 }

        public void Should_be_able_to_serialize_and_deserialize_a_message()
        {
            var initialMessage = new TestMessage {Text = "Hello!"};
            var serializedMessage = serializer.MessageToBytes(initialMessage);
            var deserializedMessage = serializer.BytesToMessage<TestMessage>(serializedMessage);

            deserializedMessage.Text.ShouldEqual(initialMessage.Text);
        }

        public void Definition_should_allow_to_retrieve_proper_correlation_id()
        {
            var message = new TestMessage { FirstId = Guid.NewGuid(), SecondId = Guid.NewGuid() };
            var def1 = MessageDefinition.Create<TestMessage>(m => m.FirstId);
            var def2 = MessageDefinition.Create<TestMessage>(m => m.SecondId);

            Assert.That(def1.GetCorrelationId(message), Is.EqualTo(message.FirstId), "It should use FirstId");
            Assert.That(def2.GetCorrelationId(message), Is.EqualTo(message.SecondId), "It should use SecondId");
        }

        public async Task WaitsForFirstMessage() {
            var task = this.EventManager.WaitFor<TestMessage, SecondTestMessage>();
            var testMessage = new TestMessage();
            this.MessageBus.Send(testMessage);
            this.React();

            var result = await task;

            Assert.AreEqual(result, testMessage);
        }

        public void Publish_calls_the_method_on_subscriber()
        {
            var simplePublishWay = new SimpleDispatcher();
            var message = new TestMessage();
            var handler = new TestHandler();

            simplePublishWay.Invoke(message, handler);

            Assert.That(handler.TestMessage, Is.SameAs(message));
        }

        public void SerialiseAndDeserialiseMessage()
        {
            var componentUnderTest = new JsonMessageSerialiser();

             var message = new TestMessage();
             var serialisedMessage = componentUnderTest.Serialise(message);
             var deserialisedMessage = componentUnderTest.Deserialise(serialisedMessage, typeof(TestMessage));

             Assert.That(deserialisedMessage, Is.Not.Null);
        }

		public void ExpectExceptionForUnreadableData()
		{
			var message = new TestMessage { content = "This message cannot be resolved!", ID = 0 };
			var memoryStream = new MemoryStream(new byte[64]);
			var binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write(BinaryDataExtensions.ToByteArray(message));
			memoryStream.Position = 0;
			var binaryReader = new BinaryReader(memoryStream);
			Assert.Throws<TypeLoadException>(() => binaryReader.Create());
		}

        public void Should_no_throw_if_no_dispatcher_found_and_set_to_ignore()
        {
            var assignee = new SimpleSubscriber();
            var handler = new TestHandler();
            var message = new TestMessage();
            var publisher = new Publisher(new PublisherSettings{IgnoreNoDispatcher = true},assignee, new[] { new SimpleDispatcher(new Rule(x => false)) });

            assignee.Subscribe(handler);

            Should.NotThrow(() => publisher.Publish(message));
        }

        private static void AssertDispatchesCall(SynchronizationContextDispatcher dispatcher)
        {
            var handler = new TestHandler();
            var message = new TestMessage();

            dispatcher.Invoke(message, handler);

            handler.Called.WaitOne(1000);

            Assert.That(handler.TestMessage, Is.SameAs(message));
        }

        public async Task Reply_ShouldContainMessageInRepliedMessages()
        {
            var context = new TestableMessageHandlerContext();
            var messageInstance = new TestMessage();
            var publishOptions = new ReplyOptions();

            await context.Reply(messageInstance, publishOptions);

            Assert.AreEqual(1, context.RepliedMessages.Length);
            Assert.AreSame(messageInstance, context.RepliedMessages[0].Message);
            Assert.AreSame(publishOptions, context.RepliedMessages[0].Options);
        }

        public async Task Send_ShouldContainMessageInSentMessages()
        {
            var context = new TestableMessageHandlerContext();
            var messageInstance = new TestMessage();
            var sendOptions = new SendOptions();

            await context.Send(messageInstance, sendOptions);

            Assert.AreEqual(1, context.SentMessages.Length);
            Assert.AreSame(messageInstance, context.SentMessages[0].Message);
            Assert.AreSame(sendOptions, context.SentMessages[0].Options);
        }

 private void When_I_Send_A_Message()
 {
     try
     {
         _testMessage = new TestMessage();
         _messageBus.Send(_testMessage);
     }
     catch (NoHandlerException e)
     {
         _expectedException = e;
     }
 }