public void ThrowArgumentException_WhenNameIsEmpty()
 {
     // Act & Assert.
     Ensure.ArgumentExceptionIsThrown(() =>
     {
         ValidatableArgument<int> argument = new ValidatableArgument<int>(string.Empty, 3);
     }, "name");
 }

 public void ThrowArgumentNullException_WhenNameArgumentIsNull()
 {
     // Act & Assert.
     Ensure.ArgumentNullExceptionIsThrown(() =>
     {
         ValidatableArgument<int> argument = new ValidatableArgument<int>(null, 3);
     }, "name");
 }

        public void ThrowArgumentNullException_WhenValidationPredicateArgumentIsNull()
        {
            // Arrange.
            IArgument<int> argument = new ValidatableArgument<int>("argument", 3);

            // Act & Assert.
            Ensure.ArgumentNullExceptionIsThrown(() =>
            {
                argument.AddValidationPredicate(null);
            }, "validationPredicate");
        }

        public void ReturnEnumerableEmpty_WhenValidationPredicatesCollectionIsEmpty()
        {
            // Arrange.
            ValidatableArgument<int> argument = new ValidatableArgument<int>("argument", 5);

            // Act.
            IEnumerable<IValidationPredicateResult> validationPredicateResults = argument.MatchValidationPredicates();

            // Assert.
            Assert.IsFalse(validationPredicateResults.Any());
        }

        public void ReturnTheSameInstance_WhenArgumentIsValidatableArgument()
        {
            // Arrange.
            IArgument<int> argument = new ValidatableArgument<int>("argument", 3);

            // Act.
            IValidatableArgument<int> validatableArgument = argument.ToValidatableArgument();

            // Assert.
            Assert.AreSame(argument, validatableArgument);
        }

        public void CopiesAllProperties_FromTheGivenIArgument()
        {
            // Arrange.
            IArgument<int> argument = new ValidatableArgument<int>("name", 5);

            // Act.
            ValidatableArgument<int> validatableArgument = new ValidatableArgument<int>(argument);

            // Assert.
            Assert.AreEqual(argument.Name, validatableArgument.Name);
            Assert.AreEqual(argument.Value, validatableArgument.Value);
        }

        public void AddGreaterThanValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<byte> argument = new ValidatableArgument<byte>("argument", 3);

            // Act.
            argument.IsGreaterThan(5);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(GreaterThanValidationPredicate<byte>));
        }

        public void AddNullableNullValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<int?> argument = new ValidatableArgument<int?>("argument", 5);

            // Act.
            argument.IsNull();

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(NullableNullValidationPredicate<int>));
        }

        public void AddNotEqualValidationPredicate_WhenArgumentIsDouble()
        {
            // Arrange.
            ValidatableArgument<double> argument = new ValidatableArgument<double>("argument", 3);

            // Act.
            argument.IsNotEqual(5);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(NotEqualValidationPredicate<double>));
        }

        public void AddLessThanValidationPredicate_WhenArgumentIsFloat()
        {
            // Arrange.
            ValidatableArgument<float> argument = new ValidatableArgument<float>("argument", 3);

            // Act.
            argument.IsLessThan(5);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(LessThanValidationPredicate<float>));
        }

        public void AddFalseValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<bool> argument = new ValidatableArgument<bool>("argument", true);

            // Act.
            argument.IsFalse();

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(FalseValidationPredicate));
        }

        public void AddGreaterThanOrEqualValidationPredicate_WhenArgumentIsDecimal()
        {
            // Arrange.
            ValidatableArgument<decimal> argument = new ValidatableArgument<decimal>("argument", 3);

            // Act.
            argument.IsGreaterThanOrEqual(5);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(GreaterThanOrEqualValidationPredicate<decimal>));
        }

        public void AddInstanceOfTypeValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<object> argument = new ValidatableArgument<object>("argument", new object());

            // Act.
            argument.IsInstanceOfType(typeof(string));

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(InstanceOfTypeValidationPredicate<object>));
        }

        public void AddEqualValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<short> argument = new ValidatableArgument<short>("argument", 3);

            // Act.
            argument.IsEqual(5);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(EqualValidationPredicate<short>));
        }

        public void ThrowArgumentException_WhenTheFirstMachingValidationRuleIsEqual()
        {
            // Arrange.
            IValidatableArgument<string> argument = new ValidatableArgument<string>("argument", "asdf");
            argument.IsNotEqual("asdf").IsEqual("asdf").IsNotNull();

            // Act & Assert.
            Ensure.ArgumentExceptionIsThrown(
                () =>
                {
                    argument.Throw();
                }, "argument");
        }

        public void AddStringNotEqualValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<string> argument =
                new ValidatableArgument<string>("argument", "abc");

            // Act.
            argument.IsNotEqual("Abc", StringComparison.OrdinalIgnoreCase);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(StringNotEqualValidationPredicate));
        }

        public void AddValidationPredicateToValidationPredicatesCollection_WhenValidationPredicateArgumentIsNotNull()
        {
            // Arrange.
            IValidationPredicate<int> validationPredicate = new LessThanValidationPredicate<int>(5);
            ValidatableArgument<int> argument = new ValidatableArgument<int>("argument", 5);

            // Act.
            argument.AddValidationPredicate(validationPredicate);

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(LessThanValidationPredicate<int>));
        }

        public void ThrowArgumentOutOfRangeException_WhenTheFirstMatchingValidationRuleIsRangeRule()
        {
            // Arrange.
            IValidatableArgument<int> argument = new ValidatableArgument<int>("argument", 5);
            argument.IsEqual(3).IsLessThan(10);

            // Act & Assert.
            Ensure.ArgumentOutOfRangeExceptionIsThrown(
                () =>
                {
                    argument.Throw();
                }, "argument");
        }

        public void AddDoubleNotInfinityValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<double> argument =
                new ValidatableArgument<double>("argument", 5);

            // Act.
            argument.IsNotInfinity();

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(DoubleNotInfinityValidationPredicate));
        }

        public void AddEnumerableNullOrEmptyValidationPredicate()
        {
            // Arrange.
            ValidatableArgument<int[]> argument =
                new ValidatableArgument<int[]>("argument", new int[] { 1, 2, 3 });

            // Act.
            argument.IsNullOrEmpty();

            // Assert.
            Assert.AreEqual(1, argument.ValidationPredicates.Count());
            Assert.IsInstanceOfType(argument.ValidationPredicates.First(), typeof(EnumerableNullOrEmptyValidationPredicate<int[]>));
        }