static (IExampleSpace <T>?exampleSpace, int countTaken) TakeRec(IExampleSpace <T> exampleSpace, int count)
{
if (count <= 0)
{
return(null, 0);
}
var takenSubspace = new List <IExampleSpace <T> >();
var countTaken = 1;
foreach (var subExampleSpace in exampleSpace.Subspace)
{
if (countTaken >= count)
{
break;
}
var(takenSubExampleSpace, subCountTaken) = TakeRec(subExampleSpace, count - countTaken);
if (takenSubExampleSpace != null)
{
takenSubspace.Add(takenSubExampleSpace);
}
countTaken += subCountTaken;
}
var takenExampleSpace = ExampleSpaceFactory.Create <T>(exampleSpace.Current, takenSubspace);
return(takenExampleSpace, countTaken);
}
public void Snapshots()
{
var tests = _fixture
.Scenarios
.Select(scenario =>
{
var exampleSpace = ExampleSpaceFactory.Int32(
scenario.Value,
scenario.Origin,
scenario.Min,
scenario.Max);
var rendering = exampleSpace.Render(x => x.ToString());
return(new
{
Input = scenario,
Output = rendering
});
})
.ToList();
foreach (var test in tests)
{
var nameExtension = $"Value={test.Input.Value};Origin={test.Input.Origin}Min={test.Input.Min};Max={test.Input.Max}";
Snapshot.Match(test.Output, SnapshotNameExtension.Create(nameExtension));
}
}
public static IGen <T> Unfold <T>(
this IGen <T> gen,
Func <T, IEnumerable <T> > shrinkValue,
Func <T, decimal>?measureValue = null,
Func <T, int>?identifyValue = null)
{
return(gen.Unfold(value => ExampleSpaceFactory.Unfold(
value,
shrinkValue.Invoke,
measureValue == null ? MeasureFunc.Unmeasured <T>() : measureValue !.Invoke,
identifyValue == null ? IdentifyFuncs.Default <T>() : value0 => ExampleId.Primitive(identifyValue !(value0)))));
}
public IGen <Test> ForANegativeRoot_ItShrinksToTheLocalMaximum() =>
from localMax in Gen.Int64().LessThan(0).GreaterThan(int.MinValue)
from root in Gen.Int64().LessThan(localMax)
select Property.ForThese(() =>
{
var exampleSpace = ExampleSpaceFactory.Int64(root, 0, long.MinValue, long.MaxValue);
var path = exampleSpace
.ExploreCounterexamples(x => x > localMax)
.Where(x => x.IsCounterexample())
.Select(x => x.Value());
path.Last().Should().Be(localMax);
});
public IGen <Test> ForAPositiveRoot_ItShrinksToTheLocalMinimum() =>
from localMin in Gen.Int64().GreaterThanEqual(0)
from root in Gen.Int64().GreaterThanEqual(localMin)
select Property.ForThese(() =>
{
var exampleSpace = ExampleSpaceFactory.Int64(root, 0, long.MinValue, long.MaxValue);
var path = exampleSpace
.ExploreCounterexamples(x => x < localMin)
.Where(x => x.IsCounterexample())
.Select(x => x.Value());
path.Should().EndWith(localMin);
});
public IGen <Test> ItShrinksToTheOrigin() =>
from origin in Gen.Int64()
from root in Gen.Int64()
select Property.ForThese(() =>
{
var exampleSpace = ExampleSpaceFactory.Int64(root, origin, long.MinValue, long.MaxValue);
var path = exampleSpace
.ExploreCounterexamples(x => false)
.Where(x => x.IsCounterexample())
.Select(x => x.Value());
path.Should().EndWith(origin);
});
static IExampleSpace <TResult> JoinExampleSpaces(
IExampleSpace <T> leftExampleSpace,
IExampleSpace <TResult> rightExampleSpace,
Func <T, IGen <TResult> > selector,
GenParameters parameters)
{
var jointExampleSpace = rightExampleSpace.MapExamples(example => new Example <TResult>(
ExampleId.Combine(leftExampleSpace.Current.Id, example.Id),
example.Value,
leftExampleSpace.Current.Distance + example.Distance));
var boundLeftSubspace = leftExampleSpace.Subspace.SelectMany(leftExampleSubspace =>
BindSubspace(leftExampleSubspace, selector, parameters));
return(ExampleSpaceFactory.Create(
jointExampleSpace.Current,
Enumerable.Concat(boundLeftSubspace, rightExampleSpace.Subspace)));
}
private static IExampleSpace <IEnumerable <T> > CreateInfiniteEnumerableSpace(
IGen <T> elementGen,
GenParameters parameters,
int?iterationLimit)
{
IEnumerable <T> SealEnumerable(IEnumerable <T> source) => ThrowOnLimit(source.Repeat(), iterationLimit);
var enumerable = CreateInfiniteEnumerable(elementGen, parameters, iterationLimit);
IExample <IEnumerable <T> > rootExample = new Example <IEnumerable <T> >(
ExampleId.Primitive(parameters.Rng.Seed),
enumerable.Select(x => x.Current.Value),
100);
return(ExampleSpaceFactory.Delay(
rootExample,
() =>
{
if (enumerable.MaxIterations == 0)
{
return Enumerable.Empty <IExampleSpace <IEnumerable <T> > >();
}
if (enumerable.MaxIterations == 1)
{
var exampleSpace = enumerable.First().Map(element => SealEnumerable(new[] { element }));
return new[] { exampleSpace };
}
var exampleSpaces = enumerable.Take(enumerable.MaxIterations).ToList();
var rootExampleExplored = ExampleSpaceFactory.Merge(
exampleSpaces,
xs => xs,
ShrinkTowardsLength(1),
(_) => 0,
enableSmallestExampleSpacesOptimization: false);
return rootExampleExplored.Subspace.Select(es => es.Map(SealEnumerable));
}));
}
public static IGen <T> NoShrink <T>(this IGen <T> gen) =>
gen.TransformInstances(instance => GenIterationFactory.Instance(
instance.ReplayParameters,
instance.NextParameters,
ExampleSpaceFactory.Singleton(instance.ExampleSpace.Current.Id, instance.ExampleSpace.Current.Value),
instance.ExampleSpaceHistory));
IEnumerable <IGenIteration <T> > GenFunc(GenParameters parameters)
{
while (true)
{
var replayParameters = parameters;
var(value, nextParameters) = func(replayParameters);
parameters = nextParameters;
yield return(GenIterationFactory.Instance(replayParameters, nextParameters, ExampleSpaceFactory.Singleton(value)));
}
}
private static IExampleSpace <T> UnfoldToNumberOfShrinks <T>(T value, int numberOfShrinks) =>
ExampleSpaceFactory.Unfold(
value,
new ShrinkNumberOfTimes <T>(numberOfShrinks),
MeasureFunc.Unmeasured <T>(),
(_) => RandomId());
