ValueGenerator<T>
using System;
using System.Collections;
using System.Collections.Generic;
namespace NUnit.Framework.Internal
{
internal abstract class ValueGenerator<T> : ValueGenerator
{
public sealed class ComparableStep<TStep> : Step where TStep : IComparable<TStep>
{
private readonly TStep _step;
private readonly Func<T, TStep, T> _apply;
public override bool IsPositive => Comparer<TStep>.Default.Compare(default(TStep), _step) < 0;
public override bool IsNegative => Comparer<TStep>.Default.Compare(_step, default(TStep)) < 0;
public ComparableStep(TStep value, Func<T, TStep, T> apply)
{
if (apply == null)
throw new ArgumentNullException("apply");
_step = value;
_apply = apply;
}
public override T Apply(T value)
{
return _apply(value, _step);
}
}
public new abstract class Step : ValueGenerator.Step
{
public abstract T Apply(T value);
}
private static Exception CreateNotSupportedException(string description)
{
return new NotSupportedException($"{typeof(T)}""{description}""");
}
public virtual int Compare(T x, T y)
{
if (!typeof(IComparable<T>).IsAssignableFrom(typeof(T)))
throw CreateNotSupportedException("comparisons");
return Comparer<T>.Default.Compare(x, y);
}
public IEnumerable<T> GenerateRange(T start, T end, Step step)
{
int startToEnd = this.Compare(start, end);
if (startToEnd != 0) {
if ((startToEnd < 0 && !step.IsPositive) || (startToEnd > 0 && !step.IsNegative))
throw new ArgumentException("Step must be in the direction of the end.");
T current = start;
while (true) {
yield return current;
T val;
try {
val = step.Apply(current);
} catch (OverflowException) {
yield break;
}
if (startToEnd < 0) {
if (this.Compare(val, end) > 0)
yield break;
if (this.Compare(val, current) <= 0)
throw new InvalidOperationException("The step must strictly increase.");
} else {
if (this.Compare(val, end) < 0)
yield break;
if (this.Compare(val, current) >= 0)
break;
}
current = val;
}
throw new InvalidOperationException("The step must strictly decrease.");
}
yield return start;
}
public sealed override IEnumerable GenerateRange(object start, object end, ValueGenerator.Step step)
{
return GenerateRange((T)start, (T)end, (Step)step);
}
public sealed override ValueGenerator.Step CreateStep(object value)
{
if (TryCreateStep(value, out ValueGenerator.Step step))
return step;
throw CreateNotSupportedException($"""{value.GetType()}");
}
public override bool TryCreateStep(object value, out ValueGenerator.Step step)
{
Guard.ArgumentNotNull(value, "value");
step = null;
return false;
}
}
}