public void WhenValueIsNotBetween_ThenThrowException(int from, int to)
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.Between(ParamValue, from, to));
Assert.That(ex.Message, Is.EqualTo($"Parameter value: '{ParamValue}' was not between '{from}' and '{to}'."));
Assert.That(ex.ParamName, Is.Null);
}
public void WhenParamValueIsInValues_ThenThrowException()
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.NotIn(ParamValue, new[] { 2, 1, 3 }));
Assert.That(ex.Message, Is.EqualTo($"Parameter value: '{ParamValue}' was in the not allowed sequence of values."));
Assert.That(ex.ParamName, Is.Null);
}
public void WhenValueIsNotBetween_AndParamNameProvided_ThenThrowException()
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.Between(ParamValue, 1, 2, ParamName));
Assert.That(ex.Message, Is.EqualTo($"Parameter value: '{ParamValue}' was not between '1' and '2'. (Parameter '{ParamName}')"));
Assert.That(ex.ParamName, Is.EqualTo(ParamName));
}
public void WhenParamNamePassedIn_ThenSetExceptionParamName()
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.NotIn(ParamValue, new[] { 2, 1, 3 }, ParamName));
Assert.That(ex.Message, Is.EqualTo($"Parameter value: '{ParamValue}' was in the not allowed sequence of values. (Parameter '{ParamName}')"));
Assert.That(ex.ParamName, Is.EqualTo(ParamName));
}
public void WhenParamIsGreaterThanValue_ThenDoNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((sbyte)2, (sbyte)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((byte)2, (byte)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((short)2, (short)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((ushort)2, (ushort)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((int)2, (int)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((uint)2, (uint)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((long)2, (long)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual((ulong)2, (ulong)1));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual(2.0f, 1.0f));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual(2.0d, 1.0d));
Assert.DoesNotThrow(() => ArgMustBe.GreaterThanOrEqual(2.0M, 1.0M));
}
public void WhenParamIsEqualToValue_ThenDoNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((sbyte)1, (sbyte)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((byte)1, (byte)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((short)1, (short)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((ushort)1, (ushort)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((int)1, (int)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((uint)1, (uint)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((long)1, (long)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual((ulong)1, (ulong)1));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual(1.0f, 1.0f));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual(1.0d, 1.0d));
Assert.DoesNotThrow(() => ArgMustBe.LessThanOrEqual(1.0M, 1.0M));
}
public void WhenParamIsGreaterThanValue_ThenThrowException()
{
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((sbyte)2, (sbyte)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((byte)2, (byte)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((short)2, (short)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((ushort)2, (ushort)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((int)2, (int)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((uint)2, (uint)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((long)2, (long)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual((ulong)2, (ulong)1));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual(2.0f, 1.0f));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual(2.0d, 1.0d));
Assert.Throws <ArgumentOutOfRangeException>(() => ArgMustBe.LessThanOrEqual(2.0M, 1.0M));
}
public void WhenParamIsLessThanValue_ThenDoNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.LessThan((sbyte)1, (sbyte)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((byte)1, (byte)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((short)1, (short)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((ushort)1, (ushort)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((int)1, (int)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((uint)1, (uint)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((long)1, (long)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan((ulong)1, (ulong)2));
Assert.DoesNotThrow(() => ArgMustBe.LessThan(1.0f, 2.0f));
Assert.DoesNotThrow(() => ArgMustBe.LessThan(1.0d, 2.0d));
Assert.DoesNotThrow(() => ArgMustBe.LessThan(1.0M, 2.0M));
}
public void WhenIsNotNull_ThenDoesNotThrowException()
{
var param = new object();
Assert.DoesNotThrow(() => ArgMustBe.NotNull(param));
}
public void WhenNullOrEmptyOrWhitespace_ThenThrowException(string value)
{
var ex = Assert.Throws <ArgumentNullOrWhiteSpaceException>(() => ArgMustBe.NotNullOrWhiteSpace(value));
Assert.That(ex.ParamName, Is.Null);
}
public void WhenDoesNotEqualValue_ThenDoNotThrowException()
{
const int param = 1;
Assert.DoesNotThrow(() => ArgMustBe.NotEquals(param, 2));
}
public void WhenEqualsValue_ThenThrowException()
{
const int param = 1;
Assert.Throws <ArgumentException>(() => ArgMustBe.NotEquals(param, 1));
}
public void WhenValueIsBetween_ThenDoNotThrowException(int from, int to)
{
Assert.DoesNotThrow(() => ArgMustBe.Between(ParamValue, from, to));
}
public void WhenValuesIsNull_ThenDoesNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.NotIn(ParamValue, null));
}
public void WhenValuesIsEmpty_ThenDoesNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.NotIn(ParamValue, Enumerable.Empty <int>()));
}
public void WhenParamValueIsNotInValues_ThenDoNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.NotIn(ParamValue, new[] { 2, 3 }));
}
public void WhenIsNotNull_ThenThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.NotNullDependency(new object()));
}
public void WhenParamIsNull_AndValueIsNotNull_ThenDoNotThrowException()
{
Assert.DoesNotThrow(() => ArgMustBe.NotEquals(null as object, 1));
}
public void WhenFromIsGreaterThanTo_ThenThrowException()
{
var ex = Assert.Throws <ArgumentException>(() => ArgMustBe.Between(ParamValue, 2, 1));
Assert.That(ex.Message, Is.EqualTo("Range from value should be less than or equal to the range to value."));
}
public void WhenNotEmpty_ThenNotThrowException(string param)
{
Assert.DoesNotThrow(() => ArgMustBe.NotEmpty(param));
}
public void WhenIsDefault_ThenThrowException()
{
const int param = default;
Assert.Throws <ArgumentDefaultException>(() => ArgMustBe.NotDefault(param));
}
public void WhenCollectionIsEmpty_ThenThrowException()
{
var x = Assert.Throws <ArgumentEmptyException>(() => ArgMustBe.NotEmpty(Enumerable.Empty <string>()));
}
public void WhenParamNamePassedIn_ThenSetExceptionParamName()
{
var ex = Assert.Throws <ArgumentNullOrWhiteSpaceException>(() => ArgMustBe.NotNullOrWhiteSpace(null, "value"));
Assert.That(ex.ParamName, Is.EqualTo("value"));
}
public void WhenIsNull_ThenThrowException()
{
Assert.Throws <DependencyNullException>(() => ArgMustBe.NotNullDependency(null as object));
}
public void WhenIsNotDefault_ThenDoesNotThrowException()
{
const int param = 1;
Assert.DoesNotThrow(() => ArgMustBe.NotDefault(param));
}
public void WhenEqualsValue_AndNull_ThenThrowException()
{
Assert.Throws <ArgumentException>(() => ArgMustBe.NotEquals(null as object, null));
}
public void WhenStringIsEmpty_ThenThrowException()
{
Assert.Throws <ArgumentEmptyException>(() => ArgMustBe.NotEmpty(string.Empty));
}
public void WhenIsNull_ThenThrowException()
{
object param = null;
Assert.Throws <ArgumentNullException>(() => ArgMustBe.NotNull(param));
}
public void WhenNotNull_AndNotEmptyString_ThenNotThrowException()
{
const string param = "Test";
Assert.DoesNotThrow(() => ArgMustBe.NotNullOrEmpty(param));
}
public void WhenNotNullOrWhiteSpace_ThenNotThrowException()
{
const string param = "Test";
Assert.DoesNotThrow(() => ArgMustBe.NotNullOrWhiteSpace(param));
}
