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");
}
