C# Command.CanExecute方法代码示例

        public void CanExecuteShouldInvokeCallback()
        {
            // arrange
            var canExecute = new Mock<Func<object, bool>>();

            canExecute.Setup( f => f( It.IsAny<object>() ) ).Returns( true );

            var command = new Command<object>( DefaultAction.None, canExecute.Object );

            // act
            command.CanExecute();

            // assert
            canExecute.Verify( f => f( null ), Times.Once() );
        }

		public void CanExecute_ShouldReturnCorrectValue(
			bool canExecute,
			object arg,
			ISchedulers schedulers,
			Mock<ICanExecuteStrategy<object>> canExecuteStrat)
		{
			//arrange
			canExecuteStrat.Setup(c => c.CanExecute(It.IsAny<object>())).Returns(canExecute);
			var sut = new Command<object>(o => { }, schedulers, "name", canExecuteStrat.Object);
			//act
			var actual = sut.CanExecute(arg);

			//assert
			actual.Should().Be(canExecute);
		}

		public void CanExecute_ShouldBeCalledWithArg(
		  object arg,
			ISchedulers schedulers,
			Mock<ICanExecuteStrategy<object>> canExecuteStrat)
		{
			//arrange
			object actual = null;
			canExecuteStrat.Setup(c => c.CanExecute(It.IsAny<object>())).Returns(true);
			var sut = new Command<object>(o => { }, schedulers, "name", canExecuteStrat.Object);

			//act
			sut.CanExecute(arg);

			//assert
			canExecuteStrat.Verify(c => c.CanExecute(arg));
		}

        internal IEnumerable<SelectedItemCollection> RunTest( IEnumerable<SelectedItemCollection> selections )
        {
            PutInOrgView(false);

            Command = CreateCommand();

            ((ICommand)Command).SetMainWindow(Program.MainWindow.CommandInterface);

            bool noneExecuted = true;

            foreach (SelectedItemCollection selection in selections)
            {
                ((ICommand)Command).SetSelection(selection);

                if (MW<bool>(() => Command.CanExecute()))
                {
                    noneExecuted = false;
                    SelectNodes(selection);

                    yield return selection;
                }
            }

            Assert.IsFalse(noneExecuted, "No tests were executed");
        }

		public void CanExecute ([Values (true, false)] bool expected)
		{
			bool canExecuteRan = false;
			var cmd = new Command (() => { }, () => {
				canExecuteRan = true;
				return expected;
			});

			Assert.AreEqual(expected, cmd.CanExecute (null));
			Assert.True (canExecuteRan);
		}

		public void GenericCanExecute ([Values (true, false)] bool expected)
		{
			string result = null;
			var cmd = new Command<string> (s => { }, s => {
				result = s;
				return expected;
			});

			Assert.AreEqual (expected, cmd.CanExecute ("Foo"));
			Assert.AreEqual ("Foo", result);
		}

		public void Constructor ()
		{
			var cmd = new Command (() => { });
			Assert.True (cmd.CanExecute (null));
		}

 public void TestCanExecIfTrue()
 {
     Command<object> command = new Command<object>(Mock.Of<Action<object>>(), () => true);
     Assert.IsTrue(command.CanExecute(null));
 }