public void ShouldCreateWithMember(string member)
{
// When
var instance = TestUtility.CreateArgument(() => member);
// Then
instance.ShouldNotBe(null);
instance.Name.ShouldBe("member");
instance.Value.ShouldBe(member);
}
public void ShouldSucceedForArgumentHasNoNullsWhenSequenceHasNoItems(object[] arrayArg, string message)
{
// Given
var argument = TestUtility.CreateArgument(() => arrayArg);
// When
var action = new TestDelegate(() => Has.NoNulls(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentIsNotNullOrEmpty(string stringArg, string message)
{
// Given
var argument = TestUtility.CreateArgument(() => stringArg);
// When
var action = new TestDelegate(() => Is.NotNullOrEmpty(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentHasLengthLessThanOrEqualToWhenArrayHasNoItems(int[] arrayArg, string message)
{
// Given
var argument = TestUtility.CreateArgument(() => arrayArg);
// When
var action = new TestDelegate(() => Has.LengthLessThanOrEqualTo <int>(() => 1)(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentHasLengthGreaterThanOrEqualToWhenArrayHasEqualNumberOfItemsPlural(int[] arrayArg, string message)
{
// Given
arrayArg = new[] { 1, 2, 3, 1, 4, 5 };
var argument = TestUtility.CreateArgument(() => arrayArg);
// When
var action = new TestDelegate(() => Has.LengthGreaterThanOrEqualTo <int>(() => 6)(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentHasLengthGreaterThanWhenArrayHasManyItems(int[] arrayArg, string message)
{
// Given
arrayArg = new[] { 1, 2, 3 };
var argument = TestUtility.CreateArgument(() => arrayArg);
// When
var action = new TestDelegate(() => Has.LengthGreaterThan <int>(() => 2)(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentHasNoDuplicatesWhenSequenceHasNoDuplicates(int[] arrayArg, string message)
{
// Given
arrayArg = new[] { 1, 2, 3 };
var argument = TestUtility.CreateArgument(() => arrayArg);
// When
var action = new TestDelegate(() => Has.NoDuplicates(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldSucceedForArgumentIsNotInWhenNotPresent(string stringArg, string message)
{
// Given
stringArg = TestData.Generic;
var argument = TestUtility.CreateArgument(() => stringArg);
// When
var action = new TestDelegate(() => Is.NotIn(() => new[] { TestData.WhiteSpace })(argument, message));
// Then
Assert.DoesNotThrow(action);
}
public void ShouldHaveDifferentHashCodeForDifferentMember(string memberOne, string memberTwo)
{
// Given
var instanceOne = TestUtility.CreateArgument(() => memberOne);
var instanceTwo = TestUtility.CreateArgument(() => memberTwo);
// When
var hashCodeOne = instanceOne.GetHashCode();
var hashCodeTwo = instanceTwo.GetHashCode();
// Then
instanceOne.ShouldNotBeSameAs(instanceTwo);
instanceOne.ShouldNotBe(instanceTwo);
hashCodeOne.ShouldNotBe(hashCodeTwo);
}
public void ShouldFailForArgumentHasLengthGreaterThanOrEqualToWhenArrayHasLessItemsSingular(int[] arrayArg, string message, string format)
{
// Given
var argument = TestUtility.CreateArgument(() => arrayArg);
var expected = string.Format(format, "Provided array parameter should have greater than or equal to 1 element, but has 0 elements", "arrayArg");
// When
var action = new TestDelegate(() => Has.LengthGreaterThanOrEqualTo <int>(() => 1)(argument, message));
// Then
var exception = Assert.Throws <ArgumentException>(action);
exception.ParamName.ShouldBe("arrayArg");
exception.Message.ShouldBe(expected);
exception.InnerException.ShouldBe(null);
}
public void ShoulFailForArgumentIsNotNullOrEmptyWhenNull(string stringArg, string message, string format)
{
// Given
var expected = string.Format(format, "Provided string should not be null", "stringArg");
var argument = TestUtility.CreateArgument(() => stringArg);
// When
var action = new TestDelegate(() => Is.NotNullOrEmpty(argument, message));
// Then
var exception = Assert.Throws <ArgumentNullException>(action);
exception.ParamName.ShouldBe("stringArg");
exception.Message.ShouldBe(expected);
exception.InnerException.ShouldBe(null);
}
public void ShoulFailForArgumentHasNoNullsWhenSequenceHasNulls(object[] arrayArg, string message, string format)
{
// Given
arrayArg = new[] { new object(), null, new object() };
var argument = TestUtility.CreateArgument(() => arrayArg);
var expected = string.Format(format, "Provided enumerable parameter should not have null(s), but had null at index 1", "arrayArg");
// When
var action = new TestDelegate(() => Has.NoNulls(argument, message));
// Then
var exception = Assert.Throws <ArgumentException>(action);
exception.ParamName.ShouldBe("arrayArg");
exception.Message.ShouldBe(expected);
exception.InnerException.ShouldBe(null);
}
public void ShouldFailForArgumentHasLengthLessThanOrEqualToWhenArrayHasMoreItemsPlural(int[] arrayArg, string message, string format)
{
// Given
arrayArg = new[] { 1, 2, 3, 1, 4, 5 };
var argument = TestUtility.CreateArgument(() => arrayArg);
var expected = string.Format(format, "Provided array parameter should have less than or equal to 2 elements, but has 6 elements", "arrayArg");
// When
var action = new TestDelegate(() => Has.LengthLessThanOrEqualTo <int>(() => 2)(argument, message));
// Then
var exception = Assert.Throws <ArgumentException>(action);
exception.ParamName.ShouldBe("arrayArg");
exception.Message.ShouldBe(expected);
exception.InnerException.ShouldBe(null);
}
public void ShouldFailForArgumentHasNoDuplicatesWhenSequenceHasDuplicates(int[] arrayArg, string message, string format)
{
// Given
arrayArg = new[] { 1, 2, 3, 1, 4, 5 };
var argument = TestUtility.CreateArgument(() => arrayArg);
var expected = string.Format(format, "Provided enumerable parameter should not have duplicate elements, but has same elements at index 0 and index 3", "arrayArg");
// When
var action = new TestDelegate(() => Has.NoDuplicates(argument, message));
// Then
var exception = Assert.Throws <ArgumentException>(action);
exception.ParamName.ShouldBe("arrayArg");
exception.Message.ShouldBe(expected);
exception.InnerException.ShouldBe(null);
}
public void ShoulFailForArgumentIsNotNullOrWhiteSpaceWhenWhiteSpace(string stringArg, string message, string format)
{
// Given
var expected = string.Format(format, "Provided string should not be empty or white space", "stringArg") + Environment.NewLine + "Actual value was " + TestData.WhiteSpace + ".";
var argument = TestUtility.CreateArgument(() => stringArg);
// When
var action = new TestDelegate(() => Is.NotNullOrWhiteSpace(argument, message));
// Then
var exception = Assert.Throws <ArgumentOutOfRangeException>(action);
exception.ParamName.ShouldBe("stringArg");
exception.Message.ShouldBe(expected);
exception.ActualValue.ShouldBe(TestData.WhiteSpace);
exception.InnerException.ShouldBe(null);
}
public void ShouldFailForArgumentIsNotInWhenPresent(string stringArg, string message, string format)
{
// Given
stringArg = TestData.Generic;
var argument = TestUtility.CreateArgument(() => stringArg);
var expected = string.Format(format, "Provided parameter should not be present in internal enumeration", "stringArg");
expected += Environment.NewLine + "Actual value was " + TestData.Generic + ".";
// When
var action = new TestDelegate(() => Is.NotIn(() => new[] { TestData.WhiteSpace, TestData.Generic })(argument, message));
// Then
var exception = Assert.Throws <ArgumentOutOfRangeException>(action);
exception.ParamName.ShouldBe("stringArg");
exception.Message.ShouldBe(expected);
exception.ActualValue.ShouldBe(TestData.Generic);
exception.InnerException.ShouldBe(null);
}
