public void SeveralSortedElements() { var inputValues = new int[] { 0, 3, 1, 4, 2, 5 }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues); var task = obs.AggregateGrouped( (i) => new List <int>(), i => i % 3, (a, i) => a.Union(new[] { i }).ToList(), (i, k, a) => new { Key = k, Value = a } ).ToListAsync(); obs.Start(); task.Wait(); Assert.AreEqual(3, task.Result.Count, "the output stream should have one element"); CollectionAssert.AreEquivalent(new[] { 0, 3 }, task.Result[0].Value); Assert.AreEqual(0, task.Result[0].Key); CollectionAssert.AreEquivalent(new[] { 1, 4 }, task.Result[1].Value); Assert.AreEqual(1, task.Result[1].Key); CollectionAssert.AreEquivalent(new[] { 2, 5 }, task.Result[2].Value); Assert.AreEqual(2, task.Result[2].Key); }
protected override IStream <TOut> CreateOutputStream(ToSubProcessesArgs <TIn, TOut> args) { // Semaphore semaphore = args.NoParallelisation ? new Semaphore(1, 1) : new Semaphore(10, 10); Synchronizer synchronizer = new Synchronizer(args.NoParallelisation); var outputObservable = args.Stream.Observable .FlatMap(i => PushObservable.FromEnumerable(args.SubProcesses.Select(sp => new { config = i, subProc = sp }))) .FlatMap(i => { EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var inputStream = new SingleStream <TIn>(this.Tracer.GetSubTracer(this), this.ExecutionContext, this.NodeName, PushObservable.FromSingle(i.config, waitHandle)); var outputStream = i.subProc(inputStream); IDisposable awaiter = null; outputStream.Observable.Subscribe(j => { }, () => awaiter?.Dispose()); return(new DeferredWrapperPushObservable <TOut>(outputStream.Observable, () => { awaiter = synchronizer.WaitBeforeProcess(); waitHandle.Set(); })); // outputStream.Observable.Subscribe(j => { }, () => semaphore.Release()); // return new DeferredWrapperPushObservable<TOut>(outputStream.Observable, () => // { // semaphore.WaitOne(); // waitHandle.Set(); // }); }); return(base.CreateUnsortedStream(outputObservable)); }
public void QuickTest2() { var rnd = new Random(); var leftList = Enumerable.Range(0, 1000).Select(i => rnd.Next(25)).OrderBy(i => i).ToList(); var rightList = Enumerable.Range(0, 100).Select(i => rnd.Next(50) / 2).OrderBy(i => i).ToList(); var expected = leftList.Where(i => !rightList.Contains(i)).OrderBy(i => i).ToList(); var left = PushObservable.FromEnumerable(leftList); var right = PushObservable.FromEnumerable(rightList); // left.Subscribe(i => System.Diagnostics.Debug.WriteLine($"left.PushValue({i});"), () => System.Diagnostics.Debug.WriteLine($"left.Complete();")); // right.Subscribe(i => System.Diagnostics.Debug.WriteLine($"______right.PushValue({i});"), () => System.Diagnostics.Debug.WriteLine($"______right.Complete();")); var output = left.Substract(right, i => i, i => i); // output.Subscribe(i => System.Diagnostics.Debug.WriteLine($"===output.PushValue({i});"), () => System.Diagnostics.Debug.WriteLine($"===output.Complete();")); var task = output.ToListAsync(); left.Start(); right.Start(); task.Wait(); System.Diagnostics.Debug.WriteLine($"->left:{string.Join(",", leftList)}"); System.Diagnostics.Debug.WriteLine($"->right:{string.Join(",", rightList)}"); System.Diagnostics.Debug.WriteLine($"->expected:{string.Join(",", expected)}"); System.Diagnostics.Debug.WriteLine($"->result:{string.Join(",", task.Result)}"); CollectionAssert.AreEquivalent(expected, task.Result); }
protected override IStream <TOut> CreateOutputStream(UnpivotArgs <TIn, TUnpivoted, TOut> args) { return(base.CreateUnsortedStream( args.InputStream.Observable.FlatMap(i => PushObservable.FromEnumerable( args.FieldsToUnpivot.Select(inp => args.ResultSelector(i, inp(i))))))); }
protected override ISortedStream <TOut, TKey> CreateOutputStream(SortArgs <TOut, TKey> args) { return(base.CreateSortedStream(args.Input.Observable.ToList().FlatMap(i => { i.Sort(args.SortDefinition); return PushObservable.FromEnumerable(i); }), args.SortDefinition)); }
protected override TStream CreateOutputStream(ThroughExcelFileArgs <TIn, TStream> args) { var firstStreamWriter = args.TargetStream.Observable.First().DelayTillEndOfStream(); var obs = args.MainStream.Observable.ToList() .CombineWithLatest(firstStreamWriter, (i, r) => { ProcessValueToOutput(r, i); return(i); }, true) .FlatMap(i => PushObservable.FromEnumerable(i)); return(CreateMatchingStream(obs, args.MainStream)); }
protected override TStream CreateOutputStream(ToEntityFrameworkCoreArgs <TIn, TCtx, TStream> args) { var dbContextStream = args.DbContextStream.Observable.First(); var ret = args.SourceStream.Observable .Chunk(args.BatchSize) .CombineWithLatest(dbContextStream, (i, c) => new { Context = c, Items = i }, true) .Do(i => ProcessBatch(i.Items.ToList(), i.Context, args.BulkLoadMode)) .FlatMap(i => PushObservable.FromEnumerable(i.Items)); return(base.CreateMatchingStream(ret, args.SourceStream)); }
public void NoElements() { var inputValues = new int[] { }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues); var task = obs.AggregateGrouped((i) => new List <int>(), i => i % 3, (a, i) => a.Union(new[] { i }).ToList(), (i, k, a) => new { Key = k, Value = a }).ToListAsync(); obs.Start(); task.Wait(); Assert.AreEqual(0, task.Result.Count, "the output stream should be empty"); }
protected override IStream <TSource> CreateOutputStream(UpdateEntityFrameworkCoreArgs <TEntity, TCtx, TSource> args) { var dbContextStream = args.DbContextStream.Observable.First(); var ret = args.SourceStream.Observable .Chunk(args.BatchSize) .CombineWithLatest(dbContextStream, (i, c) => new { Context = c, Items = i.ToList() }, true) .Do(i => this.ExecutionContext.InvokeInDedicatedThread(i.Context, () => ProcessBatch(i.Items, i.Context, args.BulkLoadMode))) .FlatMap(i => PushObservable.FromEnumerable(i.Items)); return(base.CreateUnsortedStream(ret)); }
protected override IStream <TOut> CreateOutputStream(ThroughEntityFrameworkCoreArgs <TInEf, TCtx, TIn, TOut> args) { var dbContextStream = args.DbContextStream.Observable.First(); var ret = args.SourceStream.Observable .Chunk(args.BatchSize) .CombineWithLatest(dbContextStream, (i, c) => new { Context = c, Items = i.Select(j => new Tuple <TIn, TInEf>(j, args.GetEntity(j))).ToList() }, true) .Do(i => ProcessBatch(i.Items, i.Context, args.BulkLoadMode)) .FlatMap(i => PushObservable.FromEnumerable(i.Items)) .Map(i => args.GetOutput(i.Item1, i.Item2)); return(base.CreateUnsortedStream(ret)); }
public void MapValuesWithIndex() { var input = Enumerable.Range(0, 10); var inputObservable = PushObservable.FromEnumerable(input); var outputTask = inputObservable.Map((i, idx) => new { Value = i, Index = idx }).ToListAsync(); inputObservable.Start(); outputTask.Wait(); var output = outputTask.Result; Assert.IsTrue(output.All(i => i.Index == i.Value)); }
public void FilterSectionWithOneTriggerToIgnoreWithSectionIndex2() { var inputValues = new[] { 1, 2, 0, 3, 4, 0, 5, 6 }; var expectedValues = new[] { "0-3", "0-4" }; var src = PushObservable.FromEnumerable(inputValues); var returnedTask = src.FilterSection(i => i == 0 ? SwitchBehavior.SwitchIgnoreCurrent : SwitchBehavior.KeepState, (elt, sectionIndex) => $"{sectionIndex}-{elt}").ToListAsync(); src.Start(); var returnedValues = returnedTask.Result; CollectionAssert.AreEquivalent(expectedValues, returnedValues); }
public void QuickTest() { var left = PushObservable.FromEnumerable(new[] { 1, 2, 2, 3, 4, 4, 5, 6, 7 }); var right = PushObservable.FromEnumerable(new[] { 2, 5, 5, 6 }); var output = left.Substract(right, i => i, i => i); var task = output.ToListAsync(); left.Start(); right.Start(); task.Wait(); CollectionAssert.AreEquivalent(new[] { 1, 3, 4, 4, 7 }, task.Result); }
public void OneElements() { var inputValues = new int[] { 0 }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues); var task = obs.AggregateGrouped((i) => new List <int>(), SortDefinition.Create((int i) => i % 3), (List <int> a, int i) => a.Union(new[] { i }).ToList(), (i, a) => new { Key = i, Value = a }).ToListAsync(); obs.Start(); task.Wait(); Assert.AreEqual(1, task.Result.Count, "the output stream should have one element"); CollectionAssert.AreEquivalent(new[] { 0 }, task.Result[0].Value); Assert.AreEqual(0, task.Result[0].Key); }
public void FilterSectionWithOneTriggerToKeep2() { var inputValues = new[] { 1, 2, 0, 3, 4, 0, 5, 6 }; var expectedValues = new[] { 0, 3, 4, 0 }; var src = PushObservable.FromEnumerable(inputValues); var returnedTask = src.FilterSection(i => i == 0 ? SwitchBehavior.SwitchKeepCurrent : SwitchBehavior.KeepState).ToListAsync(); src.Start(); var returnedValues = returnedTask.Result; CollectionAssert.AreEquivalent(expectedValues, returnedValues); }
public void FilterSectionStartKeepWithOneTriggerToKeepWithSectionIndex2() { var inputValues = new[] { 1, 2, 0, 3, 4, 0, 5, 6, 0, 7, 8 }; var expectedValues = new[] { "0-1", "0-2", "0-0", "1-0", "1-5", "1-6", "1-0" }; var src = PushObservable.FromEnumerable(inputValues); var returnedTask = src.FilterSection(KeepingState.Keep, i => i == 0 ? SwitchBehavior.SwitchKeepCurrent : SwitchBehavior.KeepState, (elt, sectionIndex) => $"{sectionIndex}-{elt}").ToListAsync(); src.Start(); var returnedValues = returnedTask.Result; CollectionAssert.AreEquivalent(expectedValues, returnedValues); }
protected override IStream <TSource> CreateOutputStream(UpdateEntityFrameworkCoreArgs <TEntity, TSource> args) { var ret = args.SourceStream.Observable .Chunk(args.BatchSize) .Do(i => { var dbContext = this.ExecutionContext.DependencyResolver.Resolve <DbContext>(); this.ExecutionContext.InvokeInDedicatedThreadAsync(dbContext, () => ProcessBatch(i.ToList(), dbContext, args.BulkLoadMode)).Wait(); }) .FlatMap((i, ct) => PushObservable.FromEnumerable(i, ct)); return(base.CreateUnsortedStream(ret)); }
public void PushValuesNotAutomaticStart(int nb) { var inputValues = Enumerable.Range(0, nb).ToList(); var outputValues = new List <int>(); var observable = PushObservable.FromEnumerable(inputValues); var task = observable.ToListAsync(); observable.Subscribe(outputValues.Add); observable.Start(); Assert.IsTrue(task.Wait(5000), "the stream should complete"); CollectionAssert.AreEquivalent(inputValues, outputValues); CollectionAssert.AreEquivalent(inputValues, task.Result); }
public void FilterSectionStartKeepWithOneTriggerToIgnore1() { var inputValues = new[] { 1, 0, 2, 0, 3 }; var expectedValues = new[] { 1, 3 }; var src = PushObservable.FromEnumerable(inputValues); var returnedTask = src.FilterSection(KeepingState.Keep, i => i == 0 ? SwitchBehavior.SwitchIgnoreCurrent : SwitchBehavior.KeepState).ToListAsync(); src.Start(); var returnedValues = returnedTask.Result; CollectionAssert.AreEquivalent(expectedValues, returnedValues); }
public void PushValuesStartWithEvent(int nb) { var inputValues = Enumerable.Range(0, nb).ToList(); var outputValues = new List <int>(); EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var observable = PushObservable.FromEnumerable(inputValues, waitHandle); var task = observable.ToListAsync(); observable.Subscribe(outputValues.Add); waitHandle.Set(); Assert.IsTrue(task.Wait(5000), "the stream should complete"); CollectionAssert.AreEquivalent(inputValues, outputValues); CollectionAssert.AreEquivalent(inputValues, task.Result); }
public void ListToListPushTriggeredWithEventWait() { var outputValue = 0; EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var observable = PushObservable.FromEnumerable(new[] { 1 }, waitHandle); var task = observable.ToListAsync(); observable.Subscribe(i => outputValue = i); waitHandle.Set(); var res = task.Result; Assert.AreEqual(1, outputValue); CollectionAssert.AreEquivalent(new[] { 1 }, res); }
public void WaitEndOfList() { var inputValues = Enumerable.Range(0, 1000000).ToList(); var outputValues = new List <int>(); var tmp = PushObservable.FromEnumerable(inputValues); var obs = tmp.Filter(i => i >= 0);; var output = obs.ToListAsync(); tmp.Start(); output.Wait(); CollectionAssert.AreEquivalent(inputValues, output.Result, "the output should contains only sorted values"); }
public void ListPushTriggeredWithStart() { var outputValue = 0; EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var observable = PushObservable.FromEnumerable(new[] { 1 }); var task = observable.ToTaskAsync(); observable.Subscribe(i => outputValue = i); observable.Start(); var res = task.Result; Assert.AreEqual(1, outputValue); Assert.AreEqual(1, res); }
public void SortedValues() { var inputValues = new[] { -2, -1, 0, 1, 2 }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>(); var filtered = obs.ExceptionOnUnsorted(i => i); var output = filtered.ToListAsync(); var errorList = filtered.ExceptionsToObservable().ToListAsync(); obs.Start(); output.Wait(); errorList.Wait(); CollectionAssert.AreEquivalent(inputValues, output.Result, "the output should be the same than the input"); Assert.AreEqual(0, errorList.Result.Count, "no exception should be issued in a sorted stream"); }
public void UndistinctSortedValuesForDistinct() { var inputValues = new[] { -2, -1, -1, 0, 1, 2 }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>(); var filtered = obs.ExceptionOnUnsorted(i => i, SortOrder.Ascending, true); var output = filtered.ToListAsync(); var errorList = filtered.ExceptionsToObservable().ToListAsync(); obs.Start(); output.Wait(); errorList.Wait(); CollectionAssert.AreEquivalent(new[] { -2, -1, 0, 1, 2 }, output.Result, "the output should contains only sorted values"); Assert.AreEqual(1, errorList.Result.Count, "one exception should be issued"); }
public void SimpleConcatenationWithEmptyBottomTopStartingFirst() { var obs1 = PushObservable.FromEnumerable(new[] { 1, 2 }); var obs2 = PushObservable.FromEnumerable(new int[] { }); var outputObs = obs1.Concatenate(obs2); var outputTask = outputObs.ToListAsync(); obs1.Start(); obs2.Start(); outputTask.Wait(); var output = outputTask.Result; CollectionAssert.AreEquivalent(new[] { 1, 2 }, output); }
protected override IStream <TOut> CreateOutputStream(EfCoreSaveArgs <TInEf, TIn, TOut> args) { var ret = args.SourceStream.Observable .Chunk(args.BatchSize) .Map(i => i.Select(j => (Input: j, Entity: args.GetEntity(j))).ToList()) .Do(i => { var dbContext = args.KeyedConnection == null ? this.ExecutionContext.DependencyResolver.Resolve <DbContext>() : this.ExecutionContext.DependencyResolver.Resolve <DbContext>(args.KeyedConnection); this.ExecutionContext.InvokeInDedicatedThreadAsync(dbContext, () => ProcessBatch(i, dbContext, args.BulkLoadMode)).Wait(); }) .FlatMap((i, ct) => PushObservable.FromEnumerable(i, ct)) .Map(i => args.GetOutput(i.Input, i.Entity)); return(base.CreateUnsortedStream(ret)); }
public void SimpleConcatenationWithEmptyBottomBottomStartingFirst() { EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var obs1 = PushObservable.FromEnumerable(new[] { 1, 2 }, waitHandle); var obs2 = PushObservable.FromEnumerable(new int[] { }, waitHandle); var outputObs = obs1.Concatenate(obs2); var outputTask = outputObs.ToListAsync(); waitHandle.Set(); // obs2.Start(); // obs1.Start(); outputTask.Wait(); var output = outputTask.Result; CollectionAssert.AreEquivalent(new[] { 1, 2 }, output); }
public void DistinctSortedValuesForDistinct() { var inputValues = new[] { -2, -1, 0, 1, 2 }; var outputValues = new List <int>(); var obs = PushObservable.FromEnumerable(inputValues);// new PushSubject<int>(); var filtered = obs.ExceptionOnUnsorted(i => i, SortOrder.Ascending, true); var output = filtered.ToListAsync(); var errorList = filtered.ExceptionsToObservable().ToListAsync(); obs.Start(); output.Wait(); errorList.Wait(); // Trace.Listeners.Add(new TextWriterTraceListener(Console.Out)); // Trace.WriteLine(string.Join(',', output.Result.Select(i => i.ToString()))); // Trace.WriteLine(errorList.Result.Count); Assert.AreEqual(0, errorList.Result.Count, "no exception should be issued in a sorted stream"); Assert.AreEqual(inputValues.Length, output.Result.Count, "the output should be the same size than the input"); CollectionAssert.AreEquivalent(inputValues, output.Result, "the output should be the same than the input"); }
public void FlatMapWithDeferable() { var valueStack = new Stack <int>(); var errorStack = new Stack <Exception>(); bool isComplete = false; var obs = new PushSubject <int>(); var sobs = new[] { PushObservable.FromEnumerable(new[] { 1, 2 }), PushObservable.FromEnumerable(new[] { 3, 4 }) }; var output = obs.FlatMap(i => sobs[i]); output.Subscribe(valueStack.Push, () => isComplete = true, errorStack.Push); obs.PushValue(0); System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued CollectionAssert.AreEquivalent(new[] { 1, 2 }, valueStack, "output values should be automatically issued"); obs.PushValue(1); System.Threading.Thread.Sleep(50); //the time for the 2 values to be issued CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4 }, valueStack, "output values should be automatically issued"); obs.Complete(); Assert.IsTrue(isComplete, "the output stream should be completed"); }