public string FromNative(string var) { if (IGen == null) { return(String.Empty); } if (ElementType != String.Empty) { string args = (owned ? "true" : "false") + ", " + (elements_owned ? "true" : "false"); if (IGen.QualifiedName == "GLib.PtrArray") { return(String.Format("({0}[]) GLib.Marshaller.PtrArrayToArray ({1}, {2}, typeof({0}))", ElementType, var, args)); } else { return(String.Format("({0}[]) GLib.Marshaller.ListPtrToArray ({1}, typeof({2}), {3}, typeof({4}))", ElementType, var, IGen.QualifiedName, args, element_ctype == "gfilename*" ? "GLib.ListBase.FilenameString" : ElementType)); } } else if (IGen is HandleBase) { return(((HandleBase)IGen).FromNative(var, owned)); } else if (is_null_term) { return(String.Format("GLib.Marshaller.NullTermPtrToStringArray ({0}, {1})", var, owned ? "true" : "false")); } else { return(IGen.FromNative(var)); } }
public static int Main() { //Start recording testLog.StartRecording(); // create test list IGen[] genList = new IGen[] { new Gen <int>(), new Gen <double>(), new Gen <string>(), new Gen <object>(), new Gen <Exception>() }; // run test for (int i = 0; i < genList.Length; i++) { Console.WriteLine(genList[i].ExceptionTest()); } // stop recoding testLog.StopRecording(); return(testLog.VerifyOutput()); }
public static int TestEntryPoint() { //Start recording testLog.StartRecording(); // create test list IGen[] genList = new IGen[] { new Gen <Exception>(), new Gen <GenException <Exception> >(), new Gen <GenException <GenException <Exception> > >(), new Gen <GenException <GenException <GenException <Exception> > > >(), new Gen <GenException <GenException <GenException <GenException <Exception> > > > >(), new Gen <GenException <GenException <GenException <GenException <GenException <Exception> > > > > >(), new Gen <GenException <GenException <GenException <GenException <GenException <GenException <Exception> > > > > > >(), new Gen <GenException <GenException <GenException <GenException <GenException <GenException <GenException <Exception> > > > > > > >(), new Gen <GenException <GenException <GenException <GenException <GenException <GenException <GenException <GenException <Exception> > > > > > > > >(), new Gen <GenException <GenException <GenException <GenException <GenException <GenException <GenException <GenException <GenException <Exception> > > > > > > > > >() }; // run test for (int i = 0; i < genList.Length; i++) { Console.WriteLine(genList[i].ExceptionTest()); } // stop recoding testLog.StopRecording(); return(testLog.VerifyOutput()); }
public string ToNative(string var) { if (IGen == null) { return(String.Empty); } if (ElementType.Length > 0) { string args = ", typeof (" + ElementType + "), " + (owned ? "true" : "false") + ", " + (elements_owned ? "true" : "false"); var = "new " + IGen.QualifiedName + "(" + var + args + ")"; } else if (is_null_term) { return(String.Format("GLib.Marshaller.StringArrayToNullTermPointer ({0})", var)); } if (IGen is IManualMarshaler) { return((IGen as IManualMarshaler).AllocNative(var)); } else if (IGen is ObjectGen && owned) { return(var + " == null ? IntPtr.Zero : " + var + ".OwnedHandle"); } else if (IGen is OpaqueGen && owned) { return(var + " == null ? IntPtr.Zero : " + var + ".OwnedCopy"); } else { return(IGen.CallByName(var)); } }
private static string PrintAndCollect <T>(IGen <T> gen) { var log = new List <string>(); gen.Advanced.Print(seed: 0, stdout: log.Add); return(string.Join(Environment.NewLine, log)); }
public static Type ReflectGenTypeArgument(this IGen gen) { var reflectedGenType = gen .GetType() .GetInterfaces() .Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IGen <>)) .SingleOrDefault(); return(reflectedGenType.GetGenericArguments().Single()); }
public static void Equal <T>(IGen <T> expected, IGen <T> actual, int seed, int?iterations = null) { var expectedSample = expected.Select(x => JsonConvert.SerializeObject(x)).Advanced.SampleExampleSpaces(seed: seed, iterations: iterations); var actualSample = actual.Select(x => JsonConvert.SerializeObject(x)).Advanced.SampleExampleSpaces(seed: seed, iterations: iterations); Assert.All( Enumerable.Zip(expectedSample, actualSample), (x) => { Assert.Equal(x.First.Sample(), x.Second.Sample()); }); }
public static T Minimum <T>( this IGen <T> gen, int iterations = 100, int?seed = null, int?size = null, bool deepMinimum = false, Func <T, bool>?pred = null) => gen.Advanced.MinimumWithMetrics <T>( iterations: iterations, seed: seed, size: size, deepMinimum: deepMinimum, pred: pred).Value;
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))))); }
/// <summary> /// Projects each element in a generator to a new form. /// </summary> /// <typeparam name="T">The type of the generator's value.</typeparam> /// <typeparam name="TResult">The type of the resultant generator's value.</typeparam> /// <param name="gen">The generator to apply the projection to.</param> /// <param name="selector">A projection function to apply to each value.</param> /// <returns>A new generator with the projection applied.</returns> /// <summary> /// Projects each element in a generator to a new form. /// </summary> /// <typeparam name="T">The type of the generator's value.</typeparam> /// <typeparam name="TResult">The type of the resultant generator's value.</typeparam> /// <param name="gen">The generator to apply the projection to.</param> /// <param name="selector">A projection function to apply to each value.</param> /// <returns>A new generator with the projection applied.</returns> public static IGen <TResult> Select <T, TResult>(this IGen <T> gen, Func <T, TResult> selector) { GenInstanceTransformation <T, TResult> transformation = (instance) => { var sourceExampleSpace = instance.ExampleSpace; var projectedExampleSpace = instance.ExampleSpace.Map(selector); return(GenIterationFactory.Instance( instance.ReplayParameters, instance.NextParameters, projectedExampleSpace, instance.ExampleSpaceHistory)); }; return(gen.TransformInstances(transformation)); }
public static IGen <T> Unfold <T>( this IGen <T> gen, Func <T, IExampleSpace <T> > unfolder) { GenInstanceTransformation <T, T> transformation = (instance) => { return(GenIterationFactory.Instance( instance.ReplayParameters, instance.NextParameters, unfolder(instance.ExampleSpace.Current.Value), instance.ExampleSpaceHistory)); }; return(gen.TransformInstances(transformation)); }
public static CheckResult <T> Check <T>( this IGen <Test <T> > property, int?iterations = null, int?seed = null, int?size = null, int?shrinkLimit = null, string?replay = null, bool deepCheck = true) { var resolvedIterations = iterations ?? 100; var(initialSize, resizeStrategy) = SizingAspects <T> .Resolve(size == null?null : new Size(size.Value), resolvedIterations); var initialParameters = seed == null ? GenParameters.Create(initialSize) : GenParameters.Create(Rng.Create(seed.Value), initialSize); var initialContext = new CheckStateContext <T>( property, resolvedIterations, shrinkLimit ?? 500, initialParameters, deepCheck); CheckState <T> initialState = replay == null ? new GenerationStates.Generation_Begin <T>() : new ReplayState <T>(replay); var transitions = CheckStateEnumerator.Enumerate( initialState, initialContext, new[] { new ResizeCheckStateTransitionDecorator <T>(resizeStrategy) }); var transitionAggregation = AggregateTransitions(transitions); return(new CheckResult <T>( transitionAggregation.FinalContext.CompletedIterationsUntilCounterexample, transitionAggregation.FinalContext.Discards, transitionAggregation.FinalContext.Shrinks + transitionAggregation.FinalContext.CompletedIterationsAfterCounterexample, transitionAggregation.FinalContext.Counterexample == null ? null : FromCounterexampleContext(transitionAggregation.FinalContext.Counterexample), transitionAggregation.Checks, initialParameters, transitionAggregation.FinalContext.NextParameters, transitionAggregation.TerminationReason)); }
private static SpyEnumerable <IExampleSpace <T> > CreateInfiniteEnumerable( IGen <T> elementGen, GenParameters parameters, int?iterationLimit) { var source = elementGen.Advanced .Run(parameters) .WithDiscardCircuitBreaker(_ => true, iteration => iteration.IsDiscard()) .Select(iteration => iteration.Match <IGenInstance <T>?>( onInstance: instance => instance, onError: _ => null, onDiscard: _ => null)) .Where(instance => instance != null) .Select(instance => instance !.ExampleSpace); return(new SpyEnumerable <IExampleSpace <T> >(ThrowOnLimit(source, iterationLimit))); }
public static IGen <T> Cast <T>(this IGen gen) => new FunctionalGen <T>(parameters => gen.Advanced .Run(parameters) .Select(iteration => iteration.Data.Match( onInstance: instance => GenIterationFactory.Instance <T>( iteration.ReplayParameters, iteration.NextParameters, instance.ExampleSpace.Cast <T>(), instance.ExampleSpaceHistory), onError: error => GenIterationFactory.Error <T>( iteration.ReplayParameters, iteration.NextParameters, error.GenName, error.Message), onDiscard: discard => GenIterationFactory.Discard <T>( iteration.ReplayParameters, iteration.NextParameters, discard.ExampleSpace))));
private void mutateGen_(IGen <Neuron> gen) { var neuroGen = gen as NeuroGen; var shouldMutateActivationFunc = Random.Next(0, 100) >= MutatedPropability; if (shouldMutateActivationFunc) { var index = Random.Next(1, ActivationFunctions.AvailableActivatonFunctions.Count() + 1); neuroGen.Value.ActivationFunc = ActivationFunctions.AvailableActivatonFunctions.FirstOrDefault(x => x.Index == index); } var mutatedWeightsCount = Random.Next(0, neuroGen.Weights.Count / 3); for (int i = 0; i < mutatedWeightsCount; i++) { var nextGen = Random.Next(0, mutatedWeightsCount); neuroGen.Weights[nextGen] = Random.NextDouble(); } }
public static IGen <U> TransformInstances <T, U>( this IGen <T> gen, GenInstanceTransformation <T, U> transformation) => gen.TransformIterations((IGenIteration <T> iteration) => { var either = iteration.ToEither <T, U>(); if (EitherExtension.IsLeft(either, out IGenInstance <T> instance)) { return(transformation(instance)); } else if (EitherExtension.IsRight(either, out IGenIteration <U> iterationConverted)) { return(iterationConverted); } else { throw new Exception("Fatal: Unhandled branch"); } });
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 Generator(IGen requestTimeGen, IGen firstArticleGen, IGen secondArticleGen, IGen thirdArticleGen, double urgencyProb, double refuseProb, IGen demandModifyTimeGen, IGen articlesModifyGen, IGen firstArticleModifyGen, IGen secondArticleModifyGen, IGen thirdArticleModifyGen, IGen urgToStandModifyGen, IGen standToUrgModifyGen, IGen deliveryDelayGen, IGen[] deliveryElementsModifyGens) { this.uGen = new UniformGen(0, 1); this.requestTimeGen = requestTimeGen; this.firstArticleGen = firstArticleGen; this.secondArticleGen = secondArticleGen; this.thirdArticleGen = thirdArticleGen; this.urgencyProb = urgencyProb; this.refuseProb = refuseProb; this.demandModifyTimeGen = demandModifyTimeGen; this.articlesModifyGen = articlesModifyGen; this.firstArticleModifyGen = firstArticleModifyGen; this.secondArticleModifyGen = secondArticleModifyGen; this.thirdArticleModifyGen = thirdArticleModifyGen; this.urgToStandModifyGen = urgToStandModifyGen; this.standToUrgModifyGen = standToUrgModifyGen; this.deliveryDelayGen = deliveryDelayGen; this.deliveryElementsModifyGens = deliveryElementsModifyGens; }
/// <summary> /// Filters a generator's values based on a predicate. Does not alter the structure of the stream. Instead, /// it replaces the filtered value with a token, which enables discard counting whilst running the generator. /// </summary> /// <param name="gen">The generator to apply the predicate to.</param> /// <param name="pred">A predicate function that tests each value.</param> /// <returns>A new generator with the filter applied.</returns> public static IGen <T> Where <T>(this IGen <T> gen, Func <T, bool> pred) { GenInstanceTransformation <T, T> applyPredicateToInstance = (instance) => { var filteredExampleSpace = instance.ExampleSpace.Filter(pred); if (filteredExampleSpace == null) { return(GenIterationFactory.Discard <T>( instance.ReplayParameters, instance.NextParameters, instance.ExampleSpace)); } return(GenIterationFactory.Instance( instance.ReplayParameters, instance.NextParameters, filteredExampleSpace, instance.ExampleSpaceHistory)); }; GenStreamTransformation <T, T> resizeAndTerminateAfterConsecutiveDiscards = (stream) => { const int MaxConsecutiveDiscards = 10; return(stream .WithConsecutiveDiscardCount(_ => true, iteration => iteration.IsDiscard()) .Select((x) => { var(iteration, consecutiveDiscardCount) = x; if (consecutiveDiscardCount >= MaxConsecutiveDiscards) { var resizedIteration = GenIterationFactory.Discard <T>( iteration.ReplayParameters, iteration.NextParameters.With(size: iteration.NextParameters.Size.BigIncrement()), iteration.Data.Discard !.ExampleSpace); return (iteration: resizedIteration, consecutiveDiscardCount); }
internal static IGen <T> SelectError <T>(this IGen <T> gen, Func <IGenErrorData, IGenErrorData> errorSelector) { IGenIteration <T> SelectError(IGenError <T> error) { var selectedErrorData = errorSelector(error); return(GenIterationFactory.Error <T>( error.ReplayParameters, error.NextParameters, selectedErrorData.GenName, selectedErrorData.Message)); } GenIterationTransformation <T, T> transformation = (iteration) => { return(iteration.Match( onError: error => SelectError(error), onInstance: instance => instance, onDiscard: discard => discard)); }; return(gen.TransformIterations(transformation)); }
public static void Assert <T>( this IGen <Test <T> > property, int?iterations = null, int?seed = null, int?size = null, int?shrinkLimit = null, string?replay = null, bool deepCheck = true, Func <string, string>?formatReproduction = null, Func <string, string>?formatMessage = null) { var checkResult = property.Check(iterations: iterations, seed: seed, size: size, shrinkLimit: shrinkLimit, replay: replay, deepCheck: deepCheck); if (checkResult.Falsified) { throw new PropertyFailedException( BoxCounterexample(checkResult.Counterexample !), checkResult.Iterations, checkResult.Shrinks, formatReproduction, formatMessage); } }
public string FromNative(string var) { if (IGen == null) { return(String.Empty); } if (ElementType != String.Empty) { string args = (owned ? "true" : "false") + ", " + (elements_owned ? "true" : "false"); if (IGen.QualifiedName == "GLib.PtrArray") { return(String.Format("({0}[]) GLib.Marshaller.PtrArrayToArray ({1}, {2}, typeof({0}))", ElementType, var, args)); } else { return(String.Format("({0}[]) GLib.Marshaller.ListPtrToArray ({1}, typeof({2}), {3}, typeof({4}))", ElementType, var, IGen.QualifiedName, args, element_ctype == "gfilename*" ? "GLib.ListBase.FilenameString" : ElementType)); } } else if (IGen is IOwnable) { return(((IOwnable)IGen).FromNative(var, owned)); } else if (is_null_term) { return(String.Format("Gst.Marshaller.NullTermPtrToStringArray ({0}, {1})", var, owned ? "true" : "false")); } else if (is_array) { return(String.Format("({0}) GLib.Marshaller.ArrayPtrToArray ({1}, typeof ({2}), (int){3}native_{4}, true)", CSType, var, IGen.QualifiedName, CountParameter.CSType == "int" ? String.Empty : "(" + CountParameter.CSType + ")", CountParameter.Name)); } else { return(IGen.FromNative(var)); } }
private static IGen <ImmutableList <T> > CreateImmutableListGen <T>(IGen <T> elementGen) => CreateIReadOnlyListGen(elementGen).Select(x => x.ToImmutableList());
/// <summary> /// Creates a generator that produces lists, the elements of which are produced by the given generator. By /// default, the generator produces lists ranging from count 0 to 20 - but this can be configured using the /// builder methods on <see cref="IListGen{T}"/>. /// </summary> /// <param name="elementGen">The generator used to produce the elements of the list.</param> /// <returns>The new generator.</returns> public static IListGen <T> ListOf <T>(this IGen <T> gen) => Gen.List(gen);
/// <summary> /// Creates a generator that produces lists, the elements of which are produced by the given generator. By /// default, the generator produces lists ranging from count 0 to 20 - but this can be configured using the /// builder methods on <see cref="IListGen{T}"/>. /// </summary> /// <param name="elementGen">The generator used to produce the elements of the list.</param> /// <returns>The new generator.</returns> public static IListGen <T> List <T>(IGen <T> elementGen) => new ListGen <T>( ElementGen: elementGen, Count: RangeIntention.Unspecified(), Bias: null, EnableCountLimit: null);
public static ISetGen <T> Set <T>(IGen <T> elementGen) => new SetGen <T>( ElementGen: elementGen, Count: RangeIntention.Unspecified());
/// <summary> /// Creates a generator that produces sets, the elements of which are produced by the given generator. By /// default, the generator produces sets ranging from count 0 to 20 - but this can be configured using the /// builder methods on <see cref="ISetGen{T}"/>. /// </summary> /// <param name="elementGen">The generator used to produce the elements of the set.</param> /// <returns>The new generator.</returns> public static ISetGen <T> SetOf <T>(this IGen <T> gen) => Gen.Set(gen);
private void Main_Load(object sender, EventArgs e) { notifyIcon1.Visible = true; _requestSuccess = true; _Sctime = ConfigurationManager.AppSettings["ScTime"].ToString(); _Smtime = ConfigurationManager.AppSettings["SmTime"].ToString(); _GetPriceTime = ConfigurationManager.AppSettings["GetPrice"].ToString(); Sctime.Interval = TimeHelper.ConvertHToMs(_Sctime); Smtime.Interval = TimeHelper.ConvertSToMs(_Smtime); igen = new Gen(); igen.ScanAndInsertHandler += new ScanAndInsert(igen_ScanAndInsertHandler); igen.PostDataHandler += new PostData(igen_PostData); RequesTime.Start(); this.ShowInTaskbar = false; Smtime.Start(); Sctime.Start(); }
public InfiniteGen(IGen <T> elementGen) : this(elementGen, 1000) { }
public InfiniteGen(IGen <T> elementGen, int?iterationLimit) { _elementGen = elementGen; _iterationLimit = iterationLimit; }
/// <summary> /// Creates a generator that produces infinite enumerables, the elements of which are produced by the given /// generator. Infinite enumerables are supported by this generator, but by default there is a limit of 1000 /// elements in place - and the iterator will throw if that limit is exceeded. This is a pragmatic limit to /// avert confusion of cases where the consuming code trys to enumerate an infinite enumerable (and /// consequently hangs forever). /// </summary> /// <param name="elementGen">The generator used to produce the elements of the list.</param> /// <param name="iterationLimit">The hard iteration limit that should be applied to the generator.</param> /// <returns>The new generator.</returns> public static IGen <IEnumerable <T> > InfiniteOf <T>(this IGen <T> elementGen, int?iterationLimit = 1000) => Gen.Infinite(elementGen, iterationLimit);
/// <summary> /// Creates a generator that produces infinite enumerables, the elements of which are produced by the given /// generator. Infinite enumerables are supported by this generator, but by default there is a limit of 1000 /// elements in place - and the iterator will throw if that limit is exceeded. This is a pragmatic limit to /// avert confusion of cases where the consuming code trys to enumerate an infinite enumerable (and /// consequently hangs forever). /// </summary> /// <param name="elementGen">The generator used to produce the elements of the list.</param> /// <param name="iterationLimit">The hard iteration limit that should be applied to the generator.</param> /// <returns>The new generator.</returns> public static IGen <IEnumerable <T> > Infinite <T>(IGen <T> elementGen, int?iterationLimit = 1000) => new InfiniteGen <T>(elementGen, iterationLimit);