public void ShouldThrowIfExecuteMethodDelegateNull()
 {
     Assert.Throws <ArgumentNullException>(
         () =>
     {
         var command = new CanExecuteObserverCommand(null);
     });
 }
 public void RelayCommandThrowsIfExecuteDelegateIsNull()
 {
     Assert.Throws <ArgumentNullException>(
         () =>
     {
         var command = new CanExecuteObserverCommand(null);
     });
 }
        public void CanExecuteReturnsTrueWithoutCanExecuteDelegate()
        {
            var handlers = new DelegateHandlers();
            var command  = new CanExecuteObserverCommand(handlers.Execute);

            var condition = command.CanExecute();

            Assert.True(condition);
        }
        public void RelayCommandExecuteShouldInvokeExecuteAction()
        {
            var executed = false;
            var command  = new CanExecuteObserverCommand(() => executed = true) as ICommand;

            command.Execute(new object());

            Assert.True(executed);
        }
        public void RaiseCanExecuteWithExceptionChangedNoRaiseCanExecuteChanged()
        {
            var handlers = new DelegateHandlers();
            var command  = new CanExecuteObserverCommand(handlers.Execute, () => true);
            var canExecuteChangedRaised = false;

            command.CanExecuteChanged += delegate { canExecuteChangedRaised = true; };

            Assert.False(canExecuteChangedRaised);
        }
        public void CanExecuteCallsPassedInCanExecuteDelegate()
        {
            var handlers = new DelegateHandlers();
            var command  = new CanExecuteObserverCommand(handlers.Execute, handlers.CanExecute);

            handlers.CanExecuteReturnValue = true;
            var actual = command.CanExecute();

            Assert.AreEqual(handlers.CanExecuteReturnValue, actual);
        }
        public void RelayCommandNotObservingPropertiesShouldNotRaiseOnEmptyPropertyName()
        {
            var canExecuteChangedRaised = false;
            var commandTestObject       = new CommandTestObject();
            var command = new CanExecuteObserverCommand(() => { });

            command.CanExecuteChanged += delegate { canExecuteChangedRaised = true; };

            commandTestObject.RaisePropertyChanged(null);

            Assert.False(canExecuteChangedRaised);
        }
        public void RaiseCanExecuteChangedRaisesCanExecuteChanged()
        {
            var canExecuteChangedRaised = false;

            var handlers = new DelegateHandlers();
            var command  = new CanExecuteObserverCommand(handlers.Execute, () => false);

            command.CanExecuteChanged += delegate { canExecuteChangedRaised = true; };

            CommandManager.InvalidateRequerySuggested();
            Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new Action(() => { }));

            Assert.True(canExecuteChangedRaised);
        }
        public void CanRemoveCanExecuteChangedHandler()
        {
            var command = new CanExecuteObserverCommand(() => { });
            var canExecuteChangedRaised = false;

            void Handler(object s, EventArgs e) => canExecuteChangedRaised = true;

            command.CanExecuteChanged += Handler;
            command.CanExecuteChanged -= Handler;

            CommandManager.InvalidateRequerySuggested();
            Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background, new Action(() => { }));

            Assert.False(canExecuteChangedRaised);
        }
        public void RelayCommandCanExecuteShouldInvokeCanExecuteFunc()
        {
            var invoked = false;
            var command = new CanExecuteObserverCommand(
                () => { },
                () =>
            {
                invoked = true;
                return(true);
            });

            var canExecute = command.CanExecute();

            Assert.True(invoked);
            Assert.True(canExecute);
        }