public void CanExecuteObservable_ShouldRemoveObservableCanExecute(
            ObservableCommandBuilderOptions <string, object> sut,
            IObservable <bool> observableCanExecute)
        {
            //arrange
            sut.CanExecute(() => true);

            //act
            sut.CanExecute(observableCanExecute);

            //assert
            sut.CanExecutePredicate.Should().BeNull();
        }
        public void CanExecuteOfT_ShouldSetCanExecute(
            ObservableCommandBuilderOptions <string, object> sut)
        {
            //arrange

            //act
            sut.CanExecute(_ => true);

            //assert
            sut.CanExecutePredicate(null).Should().BeTrue();
        }
        public void ToCommand_WithCanExecute_ShouldReturnCorrectValue(
            ObservableCommandBuilderOptions <string, object> sut)
        {
            //arrange

            //act
            var actual = sut.CanExecute(() => false).ToCommand();

            //assert
            actual.As <ObservableMvvmCommand <string, object> >().CanExecuteStrategy.Should().BeOfType <SingleExecutionCanExecuteStrategy <string> >()
            .Which.CanExecutePredicate(null).Should().BeFalse();
        }
        public void CanExecuteObservable_ShouldSetCanExecute(
            ObservableCommandBuilderOptions <string, object> sut,
            IObservable <bool> observableCanExecute)
        {
            //arrange

            //act
            sut.CanExecute(observableCanExecute);

            //assert
            sut.ObservableCanExecute.Should().Be(observableCanExecute);
        }
		public void ToCommand_WithCanExecute_ShouldReturnCorrectValue(
			ObservableCommandBuilderOptions<string, object> sut)
		{
			//arrange

			//act
			var actual = sut.CanExecute(() => false).ToCommand();

			//assert
			actual.As<ObservableMvvmCommand<string, object>>().CanExecuteStrategy.Should().BeOfType<SingleExecutionCanExecuteStrategy<string>>()
			      .Which.CanExecutePredicate(null).Should().BeFalse();
		}
        public void ToCommand_WithCanExecuteObservable_ShouldReturnCorrectValue(
            ObservableCommandBuilderOptions <string, object> sut,
            IObservable <bool> predicate)
        {
            //arrange

            //act
            var actual = sut.CanExecute(predicate).ToCommand();

            //assert
            actual.As <ObservableMvvmCommand <string, object> >().CanExecuteStrategy.Should().BeOfType <ObserveCanExecuteStrategy <string> >()
            .Which.CanExecuteObservable.Should().Be(predicate);
        }
        public void ToCommand_WithCanExecuteOfT_ShouldReturnCorrectValue(
            ObservableCommandBuilderOptions <string, object> sut)
        {
            //arrange
            Func <object, bool> predicate = o => true;

            //act
            var actual = sut.CanExecute(predicate).ToCommand();

            //assert
            actual.As <ObservableMvvmCommand <string, object> >().CanExecuteStrategy.Should().BeOfType <SingleExecutionCanExecuteStrategy <string> >()
            .Which.CanExecutePredicate.Should().Be(predicate);
        }
        public void ToCommand_WithObservableCanExecuteAndCallback_ShouldReturnCorrectValue(
            ObservableCommandBuilderOptions <string, object> sut,
            IObserver <object> callback,
            IScheduler scheduler,
            IObservable <bool> observableCanExecute)
        {
            //arrange

            //act
            var actual = sut.CanExecute(observableCanExecute).Do(() => callback).WithScheduler(scheduler).ToCommand();

            //assert
            actual.As <ObservableMvvmCommand <string, object> >().DoObserver().Should().Be(callback);
            actual.As <ObservableMvvmCommand <string, object> >().DoScheduler.Should().Be(scheduler);
        }
        public void ToCommand_WhenUsingObservablePredicateAndMultipleExecution_ShouldReturnCorrectValue(
            ObservableCommandBuilderOptions <string, object> sut,
            IObservable <bool> predicate
            )
        {
            //arrange

            //act
            var actual = sut.CanExecute(predicate)
                         .MultipleExecution()
                         .ToCommand();

            //assert
            actual.As <ObservableMvvmCommand <string, object> >().CanExecuteStrategy.Should().BeOfType <ObserveCanExecuteStrategy <string> >()
            .Which.InnerCanExecuteStrategy.Should().BeOfType <MultipleExecutionCanExecuteStrategy <string> >();
        }
		public void ToCommand_WithCanExecuteObservable_ShouldReturnCorrectValue(
			ObservableCommandBuilderOptions<string, object> sut,
			IObservable<bool> predicate)
		{
			//arrange

			//act
			var actual = sut.CanExecute(predicate).ToCommand();

			//assert
			actual.As<ObservableMvvmCommand<string, object>>().CanExecuteStrategy.Should().BeOfType<ObserveCanExecuteStrategy<string>>()
				.Which.CanExecuteObservable.Should().Be(predicate);
		}
		public void ToCommand_WithCanExecuteOfT_ShouldReturnCorrectValue(
			ObservableCommandBuilderOptions<string, object> sut)
		{
			//arrange
			Func<object, bool> predicate = o => true;

			//act
			var actual = sut.CanExecute(predicate).ToCommand();

			//assert
			actual.As<ObservableMvvmCommand<string, object>>().CanExecuteStrategy.Should().BeOfType<SingleExecutionCanExecuteStrategy<string>>()
				.Which.CanExecutePredicate.Should().Be(predicate);
		}
		public void ToCommand_WhenUsingObservablePredicateAndMultipleExecution_ShouldReturnCorrectValue(
			ObservableCommandBuilderOptions<string, object> sut,
			IObservable<bool>  predicate
			)
		{
			//arrange

			//act
			var actual = sut.CanExecute(predicate)
			   .MultipleExecution()
			   .ToCommand();

			//assert
			actual.As<ObservableMvvmCommand<string, object>>().CanExecuteStrategy.Should().BeOfType<ObserveCanExecuteStrategy<string>>()
			      .Which.InnerCanExecuteStrategy.Should().BeOfType<MultipleExecutionCanExecuteStrategy<string>>();
		}
		public void CanExecuteObservable_ShouldRemoveObservableCanExecute(
		  ObservableCommandBuilderOptions<string, object> sut,
			IObservable<bool> observableCanExecute)
		{
			//arrange
			sut.CanExecute(() => true);

			//act
			sut.CanExecute(observableCanExecute);

			//assert
			sut.CanExecutePredicate.Should().BeNull();
		}
		public void CanExecuteObservable_ShouldSetCanExecute(
		  ObservableCommandBuilderOptions<string, object> sut,
			IObservable<bool> observableCanExecute)
		{
			//arrange

			//act
			sut.CanExecute(observableCanExecute);

			//assert
			sut.ObservableCanExecute.Should().Be(observableCanExecute);
		}
		public void CanExecuteOfT_ShouldSetCanExecute(
		  ObservableCommandBuilderOptions<string, object> sut)
		{
			//arrange

			//act
			sut.CanExecute(_ => true);

			//assert
			sut.CanExecutePredicate(null).Should().BeTrue();
		}
		public void ToCommand_WithObservableCanExecuteAndCallback_ShouldReturnCorrectValue(
			ObservableCommandBuilderOptions<string, object> sut,
			IObserver<object> callback,
			IScheduler scheduler,
			IObservable<bool> observableCanExecute)
		{
			//arrange

			//act
			var actual = sut.CanExecute(observableCanExecute).Do(() => callback).WithScheduler(scheduler).ToCommand();

			//assert
			actual.As<ObservableMvvmCommand<string, object>>().DoObserver().Should().Be(callback);
			actual.As<ObservableMvvmCommand<string, object>>().DoScheduler.Should().Be(scheduler);
		}