public void ShouldRespectUnderlyingEnumType(Type enumType, Type underlyingType)
{
// Arrange
var sut = new EnumRangedRequestRelay();
var request =
new RangedRequest(memberType: enumType, operandType: typeof(int), minimum: 1, maximum: 2);
RangedNumberRequest capturedNumericRequest = null;
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
capturedNumericRequest = (RangedNumberRequest)r;
return(new NoSpecimen());
}
};
// Act
sut.Create(request, context);
// Assert
Assert.NotNull(capturedNumericRequest);
Assert.Equal(underlyingType, capturedNumericRequest.OperandType);
Assert.IsType(underlyingType, capturedNumericRequest.Minimum);
Assert.IsType(underlyingType, capturedNumericRequest.Maximum);
}
public void ShouldCorrectPassMinimumAndMaximum()
{
// Arrange
var sut = new EnumRangedRequestRelay();
int minimum = 5;
int maximum = 10;
var request = new RangedRequest(typeof(EnumType), typeof(int), minimum, maximum);
RangedNumberRequest capturedNumericRequest = null;
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
capturedNumericRequest = (RangedNumberRequest)r;
return(new NoSpecimen());
}
};
// Act
sut.Create(request, context);
// Assert
Assert.NotNull(capturedNumericRequest);
Assert.Equal(minimum, capturedNumericRequest.Minimum);
Assert.Equal(maximum, capturedNumericRequest.Maximum);
}
public void ShouldCorrectPassMinimumAndMaximumAsMilliseconds()
{
// Arrange
var sut = new TimeSpanRangedRequestRelay();
var request = new RangedRequest(typeof(TimeSpan), typeof(TimeSpan), "00:00:00", "12:00:00");
RangedNumberRequest capturedNumericRequest = null;
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
capturedNumericRequest = (RangedNumberRequest)r;
return(new NoSpecimen());
}
};
// Act
sut.Create(request, context);
// Assert
Assert.NotNull(capturedNumericRequest);
Assert.Equal(0.0, capturedNumericRequest.Minimum);
Assert.Equal(12 * 60 * 60 * 1000.0, capturedNumericRequest.Maximum);
}
public void ShouldCorrectPassMinimumAndMaximumAsTicks()
{
// Arrange
var sut = new DateTimeRangedRequestRelay();
var request = new RangedRequest(typeof(DateTime), typeof(DateTime), "2020-01-01 00:00:00", "2020-12-31 23:59:59");
RangedNumberRequest capturedNumericRequest = null;
var context = new DelegatingSpecimenContext
{
OnResolve = r =>
{
capturedNumericRequest = (RangedNumberRequest)r;
return(new NoSpecimen());
}
};
// Act
sut.Create(request, context);
// Assert
Assert.NotNull(capturedNumericRequest);
Assert.Equal(new DateTime(2020, 1, 1, 0, 0, 0).Ticks, capturedNumericRequest.Minimum);
Assert.Equal(new DateTime(2020, 12, 31, 23, 59, 59).Ticks, capturedNumericRequest.Maximum);
}
public void SutIsEquatable()
{
// Arrange
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
// Act & assert
Assert.IsAssignableFrom <IEquatable <RangedRequest> >(sut);
}
public void SutIsEquatable()
{
// Fixture setup
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
// Exercise system and Verify outcome
Assert.IsAssignableFrom <IEquatable <RangedRequest> >(sut);
// Teardown
}
public void ShouldCorrectlyConvertMaximum(object bounaryValue)
{
// Arrange
var sut = new RangedRequest(typeof(int), typeof(int), 0, bounaryValue);
// Act
var convertedValue = sut.GetConvertedMaximum(typeof(int));
// Assert
Assert.Equal(42, convertedValue);
}
public void SutIsNotEqualNullSut()
{
// Arrange
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
RangedRequest nullSut = null;
// Act
var areEqual = sut.Equals(nullSut);
// Assert
Assert.False(areEqual);
}
public void SutIsNotEqualOtherSutWhenAnyMemberDiffers(Type memberType, Type operandType, object min, object max)
{
// Arrange
var sut = new RangedRequest(typeof(long), typeof(int), 1, 3);
RangedRequest other = new RangedRequest(memberType, operandType, min, max);
// Act
bool areEqual = sut.Equals(other);
// Assert
Assert.False(areEqual);
}
public void ShouldCorrectlyConvertMaximum(object bounaryValue)
{
// Fixture setup
var sut = new RangedRequest(typeof(int), typeof(int), 0, bounaryValue);
// Exercise system
var convertedValue = sut.GetConvertedMaximum(typeof(int));
// Verify outcome
Assert.Equal(42, convertedValue);
// Teardown
}
public void HashCodeIsDifferentWhenAnyMemberChanges(Type memberType, Type operandType, object min, object max)
{
// Arrange
var etalonHashCode = new RangedRequest(typeof(long), typeof(int), 1, 3).GetHashCode();
var sut = new RangedRequest(memberType, operandType, min, max);
// Act
var newHashCode = sut.GetHashCode();
// Assert
Assert.NotEqual(etalonHashCode, newHashCode);
}
public void SutIsNotEqualOtherTypeObject()
{
// Arrange
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
var otherType = new object();
// Act
var areEqual = sut.Equals(otherType);
// Assert
Assert.False(areEqual);
}
public void FailsWithMeaningfulExceptionWhenMaximumCannotBeConvertedWithoutOverflow()
{
// Arrange
double valueWithOverflow = (double)long.MaxValue;
var sut = new RangedRequest(typeof(long), typeof(double), 0, valueWithOverflow);
// Act & assert
var actualEx = Assert.Throws <OverflowException>(() =>
sut.GetConvertedMaximum(typeof(long)));
Assert.Contains("To solve the issue", actualEx.Message);
}
public void ShouldReturnNoResultIfRangedRequestIsOfNonNumericMemberType(Type memberType)
{
// Arrange
var sut = new NumericRangedRequestRelay();
var request = new RangedRequest(memberType, typeof(int), 0, 42);
var context = new DelegatingSpecimenContext();
// Act
var result = sut.Create(request, context);
// Assert
Assert.IsType <NoSpecimen>(result);
}
public void SutIsNotEqualOtherObjectWhenAnyMemberDiffers(Type memberType, Type operandType, object min, object max)
{
// Fixture setup
var sut = new RangedRequest(typeof(long), typeof(int), 1, 3);
object other = new RangedRequest(memberType, operandType, min, max);
// Exercise system
bool areEqual = sut.Equals(other);
// Verify outcome
Assert.False(areEqual);
// Teardown
}
public void SutIsNotEqualNullSut()
{
// Fixture setup
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
RangedRequest nullSut = null;
// Exercise system
var areEqual = sut.Equals(nullSut);
// Verify outcome
Assert.False(areEqual);
// Teardown
}
public void SutIsNotEqualOtherTypeObject()
{
// Fixture setup
var sut = new RangedRequest(typeof(int), typeof(int), 1, 2);
var otherType = new object();
// Exercise system
var areEqual = sut.Equals(otherType);
// Verify outcome
Assert.False(areEqual);
// Teardown
}
public void HashCodeIsDifferentWhenAnyMemberChanges(Type memberType, Type operandType, object min, object max)
{
// Fixture setup
var etalonHashCode = new RangedRequest(typeof(long), typeof(int), 1, 3).GetHashCode();
var sut = new RangedRequest(memberType, operandType, min, max);
// Exercise system
var newHashCode = sut.GetHashCode();
// Verify outcome
Assert.NotEqual(etalonHashCode, newHashCode);
// Teardown
}
public void ShouldNotHandleRequestIfMemberTypeIsNotEnum()
{
// Arrange
var sut = new EnumRangedRequestRelay();
var request =
new RangedRequest(memberType: typeof(object), operandType: typeof(EnumType), minimum: 0, maximum: 1);
var context = new DelegatingSpecimenContext();
// Act
var result = sut.Create(request, context);
// Assert
Assert.Equal(new NoSpecimen(), result);
}
public void ShouldReturnNoResultIfRangedRequestIsOfNonNumericMemberType(Type memberType)
{
// Fixture setup
var sut = new NumericRangedRequestRelay();
var request = new RangedRequest(memberType, typeof(int), 0, 42);
var context = new DelegatingSpecimenContext();
// Exercise system
var result = sut.Create(request, context);
// Verify outcome
Assert.IsType <NoSpecimen>(result);
// Teardown
}
public void FailsWithMeaningfulExceptionWhenMaximumCannotBeConvertedWithoutOverflow()
{
// Fixture setup
double valueWithOverflow = (double)long.MaxValue;
var sut = new RangedRequest(typeof(long), typeof(double), 0, valueWithOverflow);
// Exercise system and verify outcome
var actualEx = Assert.Throws <OverflowException>(() =>
sut.GetConvertedMaximum(typeof(long)));
Assert.Contains("To solve the issue", actualEx.Message);
// Teardown
}
public void ShouldConvertLiteralEnumValues()
{
// Arrange
var sut = new RangedRequest(
typeof(EnumType), typeof(string), nameof(EnumType.First), nameof(EnumType.Third));
// Act
var convertedMin = sut.GetConvertedMinimum(typeof(EnumType));
var convertedMax = sut.GetConvertedMaximum(typeof(EnumType));
// Assert
Assert.Equal(EnumType.First, convertedMin);
Assert.Equal(EnumType.Third, convertedMax);
}
public void ToStringShouldBeOverridden()
{
// Arrange
var sut = new RangedRequest(typeof(long), typeof(int), 42, 100);
// Act
var stringResult = sut.ToString();
// Assert
Assert.Contains("Int32", stringResult);
Assert.Contains("Int64", stringResult);
Assert.Contains("42", stringResult);
Assert.Contains("100", stringResult);
}
public void ShouldFailWithMeaningfulExceptionIfUnableToCastWithoutOverflow()
{
// Arrange
var sut = new NumericRangedRequestRelay();
double overflowedValue = long.MaxValue;
var request = new RangedRequest(typeof(long), typeof(double), 0, overflowedValue);
var context = new DelegatingSpecimenContext();
// Act & assert
var ex = Assert.Throws <OverflowException>(() =>
sut.Create(request, context));
Assert.Contains("To solve the issue", ex.Message);
}
public void ToStringShouldBeOverridden()
{
// Fixture setup
var sut = new RangedRequest(typeof(long), typeof(int), 42, 100);
// Exercise system
var stringResult = sut.ToString();
// Verify outcome
Assert.Contains("Int32", stringResult);
Assert.Contains("Int64", stringResult);
Assert.Contains("42", stringResult);
Assert.Contains("100", stringResult);
// Teardown
}
public void ShouldReturnNoSpecimenIfUnableToSatisfyRangedRequest()
{
// Arrange
var sut = new EnumRangedRequestRelay();
var request =
new RangedRequest(memberType: typeof(EnumType), operandType: typeof(int), minimum: 1, maximum: 2);
var context = new DelegatingSpecimenContext
{
OnResolve = _ => new NoSpecimen()
};
// Act
var result = sut.Create(request, context);
// Assert
Assert.Equal(new NoSpecimen(), result);
}
public void ShouldCorrectlyConvertNumericValue(EnumType expectedResult, int numericValue)
{
// Arrange
var sut = new EnumRangedRequestRelay();
var request =
new RangedRequest(memberType: typeof(EnumType), operandType: typeof(int), minimum: 1, maximum: 3);
var context = new DelegatingSpecimenContext
{
OnResolve = _ => numericValue
};
// Act
var result = sut.Create(request, context);
// Assert
Assert.Equal(expectedResult, result);
}
public void SutIsEqualOtherObjectIfAllMembersEqual()
{
// Arrange
var memberType = typeof(decimal);
var operandType = typeof(int);
var min = 1;
var max = 3;
var sut = new RangedRequest(memberType, operandType, min, max);
object other = new RangedRequest(memberType, operandType, min, max);
// Act
bool areEqual = sut.Equals(other);
// Assert
Assert.True(areEqual);
}
public void PropertiesShouldReturnPassedToConstructorValues()
{
// Arrange
var memberType = typeof(object);
var operandType = typeof(int);
var min = 42;
var max = 100;
// Act
var sut = new RangedRequest(memberType, operandType, min, max);
// Assert
Assert.Equal(memberType, sut.MemberType);
Assert.Equal(operandType, sut.OperandType);
Assert.Equal(min, sut.Minimum);
Assert.Equal(max, sut.Maximum);
}
public void ShouldCorrectlyConvertDateTime()
{
// Fixture setup
var minimum = DateTime.MinValue;
var maximum = DateTime.MaxValue;
var sut = new RangedRequest(typeof(DateTime), typeof(DateTime), minimum.ToString("o"), maximum.ToString("o"));
// Exercise system
var convertedMinimumValue = sut.GetConvertedMinimum(typeof(DateTime));
var convertedMaximumValue = sut.GetConvertedMaximum(typeof(DateTime));
// Verify outcome
Assert.Equal(minimum, convertedMinimumValue);
Assert.Equal(maximum, convertedMaximumValue);
// Teardown
}
