ValueGenerator
using System;
using System.Collections;
using System.Linq;
using System.Reflection;
namespace NUnit.Framework.Internal
{
internal abstract class ValueGenerator
{
private sealed class ByteValueGenerator : ValueGenerator<byte>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is byte) {
step = new ComparableStep<byte>((byte)value, (byte prev, byte stepValue) => (byte)(prev + stepValue));
return true;
}
if (value is int) {
step = new ComparableStep<int>((int)value, (byte prev, int stepValue) => (byte)(prev + stepValue));
return true;
}
return base.TryCreateStep(value, out step);
}
}
public abstract class Step
{
public abstract bool IsPositive { get; }
public abstract bool IsNegative { get; }
}
private sealed class DecimalValueGenerator : ValueGenerator<decimal>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is decimal) {
step = new ComparableStep<decimal>((decimal)value, delegate(decimal prev, decimal stepValue) {
decimal num = prev + stepValue;
if ((stepValue > decimal.Zero) ? (num <= prev) : (prev <= num))
throw new ArithmeticException($"""{prev}""{stepValue}""{num}""");
return num;
});
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class DefaultValueGenerator<T> : ValueGenerator<T>
{
}
private sealed class DoubleValueGenerator : ValueGenerator<double>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is double) {
step = new ComparableStep<double>((double)value, delegate(double prev, double stepValue) {
double num = prev + stepValue;
if ((stepValue > 0) ? (num <= prev) : (prev <= num))
throw new ArithmeticException($"""{prev:""}""{stepValue:""}""{num:""}""");
return num;
});
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class Int16ValueGenerator : ValueGenerator<short>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is short) {
step = new ComparableStep<short>((short)value, (short prev, short stepValue) => checked((short)(prev + stepValue)));
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class Int32ValueGenerator : ValueGenerator<int>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is int) {
step = new ComparableStep<int>((int)value, (int prev, int stepValue) => checked(prev + stepValue));
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class Int64ValueGenerator : ValueGenerator<long>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is long) {
step = new ComparableStep<long>((long)value, (long prev, long stepValue) => checked(prev + stepValue));
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class SByteValueGenerator : ValueGenerator<sbyte>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is sbyte) {
step = new ComparableStep<sbyte>((sbyte)value, (sbyte prev, sbyte stepValue) => checked((sbyte)(prev + stepValue)));
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class SingleValueGenerator : ValueGenerator<float>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
if (value is float) {
step = new ComparableStep<float>((float)value, delegate(float prev, float stepValue) {
float num = prev + stepValue;
if ((stepValue > 0) ? (num <= prev) : (prev <= num))
throw new ArithmeticException($"""{prev:""}""{stepValue:""}""{num:""}""");
return num;
});
return true;
}
return base.TryCreateStep(value, out step);
}
}
private sealed class UInt16ValueGenerator : ValueGenerator<ushort>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
checked {
if (value is ushort) {
step = new ComparableStep<ushort>((ushort)value, (ushort prev, ushort stepValue) => (ushort)(unchecked((int)prev) + unchecked((int)stepValue)));
return true;
}
if (value is int) {
step = new ComparableStep<int>((int)value, (ushort prev, int stepValue) => (ushort)(unchecked((int)prev) + stepValue));
return true;
}
return base.TryCreateStep(value, out step);
}
}
}
private sealed class UInt32ValueGenerator : ValueGenerator<uint>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
checked {
if (value is uint) {
step = new ComparableStep<uint>((uint)value, (uint prev, uint stepValue) => prev + stepValue);
return true;
}
if (value is int) {
step = new ComparableStep<int>((int)value, (uint prev, int stepValue) => (uint)(unchecked((long)prev) + unchecked((long)stepValue)));
return true;
}
return base.TryCreateStep(value, out step);
}
}
}
private sealed class UInt64ValueGenerator : ValueGenerator<ulong>
{
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
checked {
if (value is ulong) {
step = new ComparableStep<ulong>((ulong)value, (ulong prev, ulong stepValue) => prev + stepValue);
return true;
}
if (value is int) {
step = new ComparableStep<int>((int)value, (ulong prev, int stepValue) => prev + (ulong)stepValue);
return true;
}
return base.TryCreateStep(value, out step);
}
}
}
private static readonly MethodInfo GenericCreateMethod = typeof(ValueGenerator).GetMethods(BindingFlags.Static | BindingFlags.Public).Single(delegate(MethodInfo method) {
if (method.Name == "Create")
return method.IsGenericMethod;
return false;
});
public abstract IEnumerable GenerateRange(object start, object end, Step step);
public static ValueGenerator Create(Type valueType)
{
return ((Func<ValueGenerator>)GenericCreateMethod.MakeGenericMethod(valueType).CreateDelegate(typeof(Func<ValueGenerator>)))();
}
public static ValueGenerator<T> Create<T>()
{
if (typeof(T) == typeof(sbyte))
return (ValueGenerator<T>)new SByteValueGenerator();
if (typeof(T) == typeof(byte))
return (ValueGenerator<T>)new ByteValueGenerator();
if (typeof(T) == typeof(short))
return (ValueGenerator<T>)new Int16ValueGenerator();
if (typeof(T) == typeof(ushort))
return (ValueGenerator<T>)new UInt16ValueGenerator();
if (typeof(T) == typeof(int))
return (ValueGenerator<T>)new Int32ValueGenerator();
if (typeof(T) == typeof(uint))
return (ValueGenerator<T>)new UInt32ValueGenerator();
if (typeof(T) == typeof(long))
return (ValueGenerator<T>)new Int64ValueGenerator();
if (typeof(T) == typeof(ulong))
return (ValueGenerator<T>)new UInt64ValueGenerator();
if (typeof(T) == typeof(float))
return (ValueGenerator<T>)new SingleValueGenerator();
if (typeof(T) == typeof(double))
return (ValueGenerator<T>)new DoubleValueGenerator();
if (typeof(T) == typeof(decimal))
return (ValueGenerator<T>)new DecimalValueGenerator();
return new DefaultValueGenerator<T>();
}
public abstract Step CreateStep(object value);
public abstract bool TryCreateStep(object value, out Step step);
}
}