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());