public static IEnumerable <object[]> Negative_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Negative(Convert),
new[] { new object[] { 0.000001D, false } },
new[] { new object[] { -0.000001D, true } }));
}
public static IEnumerable <object[]> BetweenOrEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.BetweenOrEqualTo_Unsigned(Convert),
NumbersTestData.BetweenOrEqualTo_Signed(Convert),
NumbersTestData.BetweenOrEqualTo_Limits(long.MinValue, long.MaxValue, 0)));
}
public static IEnumerable <object[]> NonZero_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NonZero_Unsigned(Convert),
NumbersTestData.NonZero_Signed(Convert),
NumbersTestData.NonZero_Signed_Limits(double.MinValue, double.MaxValue)));
}
public static IEnumerable <object[]> GreaterThan_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.GreaterThan_Unsigned(Convert),
NumbersTestData.GreaterThan_Signed(Convert),
NumbersTestData.GreaterThan_Limits(long.MinValue, long.MaxValue, 0)));
}
public static IEnumerable <object[]> NotEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NotEqualTo_Unsigned(Convert),
NumbersTestData.NotEqualTo_Signed(Convert),
NumbersTestData.NotEqualTo_Limits(decimal.MinValue, decimal.MaxValue, 0)));
}
public static IEnumerable <object[]> NotEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NotEqualTo_Unsigned(Convert),
NumbersTestData.NotEqualTo_Signed(Convert),
NumbersTestData.NotEqualTo_Limits(double.MinValue, double.MaxValue, 0),
new[] { new object[] { 0.999999D, 0D, true } },
new[] { new object[] { 1.000001D, 0D, true } },
new[] { new object[] { 1.123456D, 1.123456D, false } }));
}
public static IEnumerable <object[]> Between_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Between_Unsigned(Convert),
NumbersTestData.Between_Signed(Convert),
NumbersTestData.Between_Limits(float.MinValue, float.MaxValue, 0),
new[] { new object[] { 0.999999F, 1, 1.000001F, true } },
new[] { new object[] { 0.999999F, 0.999999F, 1.000001F, false } },
new[] { new object[] { 0.999999F, 1.000001F, 1.000001F, false } }));
}
public static IEnumerable <object[]> EqualTo_WithTolerance_Should_CollectError_MemberData()
{
return(RulesHelper.GetTestDataCombined(
new[] { new object[] { 1.000100D, 1.000199D, 0.0000001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.000001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.00001D, false } },
new[] { new object[] { 1.000100D, 1.000199D, 0.0001D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.001D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.01D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 0.1D, true } },
new[] { new object[] { 1.000100D, 1.000199D, 1D, true } }));
}
public static IEnumerable <object[]> NonZero_WithTolerance_Should_CollectError_MemberData()
{
return(RulesHelper.GetTestDataCombined(
new[] { new object[] { 0.000100F, 0.0000001F, true } },
new[] { new object[] { 0.000100F, 0.000001F, true } },
new[] { new object[] { 0.000100F, 0.00001F, true } },
new[] { new object[] { 0.000100F, 0.0001F, true } },
new[] { new object[] { 0.000100F, 0.001F, false } },
new[] { new object[] { 0.000100F, 0.01F, false } },
new[] { new object[] { 0.000100F, 0.1F, false } },
new[] { new object[] { 0.000100F, 1F, false } }));
}
public static IEnumerable <object[]> LessThan_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.LessThan_Unsigned(Convert),
NumbersTestData.LessThan_Limits(byte.MinValue, byte.MaxValue, 1)));
}
public static IEnumerable <object[]> BetweenOrEqualTo_Should_CollectError_When_TimeComparisonSet_Data()
{
return(RulesHelper.GetTestDataCombined(
TimesTestData.BetweenOrEqualTo(ConvertDateTimeOffset)));
}
public static IEnumerable <object[]> Positive_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Positive_Unsigned(Convert),
NumbersTestData.Positive_Signed(Convert)));
}
public static IEnumerable <object[]> GreaterThanOrEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.GreaterThanOrEqualTo_Unsigned(Convert),
NumbersTestData.GreaterThanOrEqualTo_Limits(char.MinValue, char.MaxValue, 1)));
}
public static IEnumerable <object[]> Before_Should_CollectError_When_TimeComparisonSet_Data()
{
return(RulesHelper.GetTestDataCombined(
TimesTestData.Before(ConvertDateTime)));
}
public static IEnumerable <object[]> BeforeOrEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.LessThanOrEqualTo_Unsigned(Convert),
NumbersTestData.LessThanOrEqualTo_Limits(DateTime.MinValue, DateTime.MaxValue, new DateTime(1))));
}
public static IEnumerable <object[]> BetweenOrEqualTo_Should_ThrowException_When_MinLargerThanMax_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Between_InvalidRange(Convert, short.MinValue, short.MaxValue)));
}
public static IEnumerable <object[]> Between_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.Between_Unsigned(Convert),
NumbersTestData.Between_Limits(char.MinValue, char.MaxValue, 1)));
}
public static IEnumerable <object[]> NonNegative_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.NonNegative(Convert)));
}
public static IEnumerable <object[]> LessThanOrEqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.LessThanOrEqualTo_Unsigned(Convert),
NumbersTestData.LessThanOrEqualTo_Limits(ulong.MinValue, ulong.MaxValue, 1UL)));
}
public static IEnumerable <object[]> After_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.GreaterThan_Unsigned(Convert),
NumbersTestData.GreaterThan_Limits(DateTimeOffset.MinValue, DateTimeOffset.MaxValue, new DateTimeOffset(1, TimeSpan.Zero))));
}
public static IEnumerable <object[]> EqualTo_Should_CollectError_Data()
{
return(RulesHelper.GetTestDataCombined(
NumbersTestData.EqualTo_Unsigned(Convert),
NumbersTestData.EqualTo_Limits(ushort.MinValue, ushort.MaxValue, 1)));
}
