//Currently used to do manual SQL commands from program.
        private void SearchText_KeyUp(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                if (SearchText.Text.Equals("send"))
                {
                    Messenger m = new Messenger();
                    m.sendSelect("SELECT * FROM `keys`;", "keys");
                }
                else
                {
                    Messenger m = new Messenger();

                    string[] parsed = SearchText.Text.Split(';');
                    string username = parsed[0];
                    string password = parsed[1];

                    if (m.login(username, password))
                        SearchText.Text = "Logged in.";
                    else
                        SearchText.Text = "Invalid.";
                    //m.test();
                }

               // SearchText.Text = "";
            }

        }

        public void FlyoutStaysOpenIfWanted()
        {
            // Arrange
            var currentProject = new ProjectViewModel( new Project { Id = 123 } );
            var messenger = new Messenger();
            var todoRepoMock = new Mock<ITodoRepository>();

            bool messageReceived = false;
            messenger.Register<FlyoutMessage>( this, msg => { if( msg.FlyoutName == FlyoutMessage.AddEntryFlyoutName ) messageReceived = true; } );

            var vm = new AddEntryViewModel( Enumerable.Empty<TagViewModel>(), currentProject, todoRepoMock.Object, messenger )
            {
                Summary = "summary"
            };

            // Act
            vm.StayOpen = true;
            vm.AddCommand.Execute( null );
            bool stay = messageReceived;

            vm.Summary = "summary";
            vm.StayOpen = false;
            vm.AddCommand.Execute( null );
            bool dontStay = messageReceived;

            // Assert
            Assert.IsFalse( stay );
            Assert.IsTrue( dontStay );
        }

        public void Setup()
        {
            _messenger = new Messenger();

            _productsServiceMock = new Mock<IProductsService>();
            _viewModel = new ProductListViewModel(_messenger, _productsServiceMock.Object);
        }

        public CommunicatorIntegration()
        {
            try
            {
                m_Messenger = new Messenger();
            }
            catch (Exception)
            {
                throw new CommunicatorNotOpenException();
            }

            m_ServiceID = m_Messenger.MyServiceId;

            try
            {
                m_Messenger.GetContact("[email protected]", m_ServiceID);
            }
            catch (Exception)
            {
                throw new CommunicatorNotLoggedInToRedgateException();
            }

            m_SubscribedContacts = new Dictionary<string, IMessengerContact>();

            m_Messenger.OnContactStatusChange += communicator_OnContactStatusChange;
        }

        public void AddUsesCorrectValues()
        {
            // Arrange
            var tags = new[]
            {
                new TagViewModel( new Tag {Id = 1, Name = "Tag1"} ),
                new TagViewModel( new Tag {Id = 2, Name = "Tag2"} )
            };

            var currentProject = new ProjectViewModel( new Project { Id = 123 } );

            var messenger = new Messenger();
            bool addMessageReceived = false;
            messenger.Register<EntryAddedMessage>( this, msg => addMessageReceived = true );

            var todoRepoMock = new Mock<ITodoRepository>();
            todoRepoMock.Setup( x => x.Add( It.Is<Todo>( t => t.Summary.Equals( "summary" ) && t.Details.Equals( "details" ) && t.Project.Id == 123 ) ) ).Verifiable();
            todoRepoMock.Setup( x => x.Update( It.Is<Todo>( t => t.Tags.First().Id == 2 ) ) ).Verifiable();

            var vm = new AddEntryViewModel( tags, currentProject, todoRepoMock.Object, messenger )
            {
                Summary = "summary",
                Details = "details"
            };

            // Act
            vm.Tags[1].IsSelected = true;
            vm.AddCommand.Execute( null );

            // Assert
            todoRepoMock.VerifyAll();
            Assert.IsTrue( addMessageReceived );
        }

        static void Main()
        {
            Directory.CreateDirectory(LogDir);

            var messenger = new Messenger();

            foreach (var contact in EmailAddresses
                                    .Select(emailAddress => messenger.GetContact(emailAddress, messenger.MyServiceId)))
            {
                Contacts.Add(contact);

                Log(contact);

                // Don't release the COM object of contact here
                // or OnContactStatusChange will not be raised.
            }

            messenger.OnContactStatusChange += (contact, _) => Log((IMessengerContactAdvanced)contact);

            Console.ReadLine();

            foreach (var contact in Contacts)
            {
                Marshal.FinalReleaseComObject(contact);
            }

            Marshal.FinalReleaseComObject(messenger);
        }

		public void Messager_Unsubscription_Test(int countSend)
		{
			var subscriber1 = new FakeSubscriber();
			var subscriber2 = new FakeSubscriber();
			var message = new FakeOneMessage { Text = "Test message" };
			var messenger = new Messenger();
			byte firstSubscriberNumber = 0;
			byte secondSubscriberNumber = 0;

			messenger.Subscribe<FakeOneMessage>(subscriber1, (s, m) =>
				{
					firstSubscriberNumber++;
					messenger.Unsubscribe<FakeOneMessage>(subscriber1);
				});
			messenger.Subscribe<FakeOneMessage>(subscriber2, (s, m) =>
				{
					secondSubscriberNumber++;
				});
			
			for (int i = 0; i < countSend; i++)
			{
				messenger.Send(message);
			}

			Assert.AreEqual(1, firstSubscriberNumber);
			Assert.AreEqual(countSend, secondSubscriberNumber);
		}

        public void TestMultipleRecipients()
        {
            var messenger = new Messenger();
            var recipient1 = new OldTestRecipient();
            var recipient2 = new OldTestRecipient();
            var recipient3 = new OldTestRecipient();

            messenger.Register(recipient1, typeof(OldTestMessage));
            messenger.Register(recipient2, typeof(OldTestMessage));
            messenger.Register(recipient3, typeof(OldTestMessage));

            Assert.IsNull(recipient1.Sender);
            Assert.IsNull(recipient1.Content);
            Assert.IsNull(recipient2.Content);
            Assert.IsNull(recipient2.Sender);
            Assert.IsNull(recipient3.Content);
            Assert.IsNull(recipient3.Sender);

            const string TestString = "Hello world";
            var message = new OldTestMessage(this, TestString);
            messenger.Broadcast(message);

            Assert.AreEqual(TestString, recipient1.Content);
            Assert.AreEqual(this, recipient1.Sender);
            Assert.AreEqual(TestString, recipient2.Content);
            Assert.AreEqual(this, recipient2.Sender);
            Assert.AreEqual(TestString, recipient3.Content);
            Assert.AreEqual(this, recipient3.Sender);
        }

        public NaviMessengerService()
        {
            naviMessenger = new Messenger(new NaviHandler(this));
            InitEnvParameters();
            ConnectPIC32();

            //Create navigation algorithms thread 
            ThreadAlgorithm = new Thread(new ThreadStart(algorithms));
            ThreadAlgorithm.IsBackground = true;
            ThreadAlgorithm.Priority = System.Threading.ThreadPriority.AboveNormal;

            //Init timer1
            timer1 = new System.Timers.Timer();
            timer1.Interval = 200;
            timer1.Elapsed += new System.Timers.ElapsedEventHandler(timer1_Tick);
            timer1.Stop();
            //Init manual mode timer
            ManModeTimer = new System.Timers.Timer();
            ManModeTimer.Interval = 100;
            ManModeTimer.Elapsed += new System.Timers.ElapsedEventHandler(ManModeTimerHandler);
            ManModeTimer.Stop();
            //Read config from default.set and process map
            ProcessConfigMap();
            //Connect beacon and start sendcoordinatetimer and TagDataRecvTimer
            ConnectBeacon();
        }

        protected override void OnStartup(StartupEventArgs e)
        {
            XmlConfigurator.Configure();

            _logger.Info("[START]");
            _logger.Info("setup dependency injection container");
            Container = new UnityContainer();

            _logger.Info("setup database");
            string directory = Environment.GetFolderPath(
                Environment.SpecialFolder.LocalApplicationData);
            _logger.Info("database directory: " + directory);
            _dbContext = new NDatabaseConnector(directory);

            //database registration
            Container.RegisterInstance(typeof (IDataAccessLayer), _dbContext);

            //service registrations
            Container.RegisterType<ICryptographyService, CryptographyService>();
            Container.RegisterType<IDropboxService, DropboxService>();

            //registraions utils
            //only one instance from messenger can exists! (recipient problems..)
            _logger.Info("register messenger instance");
            var messenger = new Messenger();
            Container.RegisterInstance(typeof (IMessenger), messenger);

            _logger.Info("show login view");
            var loginView = Container.Resolve<LoginView>();
            loginView.Show();
        }

 public MainWindowViewModel(Messenger messenger)
 {
     Workspaces = new ObservableCollection<IWorkspace>();
     Workspaces.CollectionChanged += Workspaces_CollectionChanged;
     SearchCustomerCommand = new RelayCommand(SearchCustomer);
     CreateCustomerCommand = new RelayCommand(() => messenger.Send(new OpenDialogWindowMessage(new CustomerViewModel(new Customer()), r => MessageBox.Show(r.ToString()))));
 }

        private void Control_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            var messenger = new Messenger();

            messenger.Register<UpdateHeaderMessage>(this, m => UpdateHeader(m));

            DataContext = new ControlViewModel(messenger);
        }

        public ControlViewModel(Messenger messenger)
        {
            _messenger = messenger;

            Connect();

            ConnectCommand = new RelayCommand(() => Connect());
        }

        public override IBinder OnBind(Intent intent)
        {
            if (intent.GetParcelableExtra("MESSENGER") != null) {
             this.outMessenger = (Messenger) intent.GetParcelableExtra("MESSENGER");
            }

            return inMessenger.Binder;
        }

    public void Initialise(UserInterface userInterface)
    {
        UserInterface = userInterface;
        Connection = gameObject.AddComponent<Connection>();
        MessageHandler = new MessageHandler(Connection);
        Messenger = new Messenger(Connection);

        MessageHandler.OnAny += MessageHandler_OnMessage;
    }

 /// <summary>
 /// Create a new host for this module
 /// </summary>
 /// <param name="mod">The module to host</param>
 public ModuleHost(AbstractModule mod, ServerContext context, Messenger messenger, BaseConfiguration config)
 {
     this.HostedModule = mod;
     this.ExitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
     mod.Messenger = messenger;
     mod.SetConfiguration(config);
     mod.SetContext(context);
     mod.OnFinishedStopping += env_OnFinishedStopping;
 }

 public MessagingTests()
 {
     var iocContainer = MockRepository.GenerateMock<IIocContainer>();
     var sendMessageHandlerType = typeof(TestActions.SendMessageHandler);
     iocContainer.Expect(x => x.Resolve(sendMessageHandlerType))
         .Return(new TestActions.SendMessageHandler());
     var messageHandlerTypes = new SimpleList<Type> { sendMessageHandlerType };
     var executionManager = new SimpleExecutionManager();
     var smartOperator = new SmartOperator(iocContainer, executionManager, messageHandlerTypes);
     _messenger = new Messenger<object>(smartOperator);
 }

 public static void AddMessage(this TempDataDictionary tempData, Message message)
 {
     dynamic messenger;
     if (tempData.TryGetValue(Messenger.Name, out messenger))
         messenger.Add(message);
     else
     {
         messenger = new Messenger();
         messenger.Add(message);
         tempData[Messenger.Name] = messenger;
     }
 }

        public void Initialize()
        {
            _target = new Messenger();
            _receivedMessage = false;

            _listenerStrongRef = new Listener
            {
                _testObject = this
            };
            _listenerWeakReference = new WeakReference(_listenerStrongRef);
            _listenerStrongRef.Subscribe(_target);
        }

        public void AMessageIsRecievedJustOnceWithOneSubscriber()
        {
            var callbackCount = 0;

            var messenger = new Messenger();
            var mockMessage = new Mock<Message>(this);

            messenger.Subscribe<Message>(message => callbackCount++);
            messenger.Publish(mockMessage.Object);

            Assert.IsTrue(callbackCount == 1);
        }