public async Task Composition6()
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
var finaliser1 = PipeLine.Create <int, int>(i => i * 3).Next(i => Console.WriteLine("1 - {0} {1}", Thread.CurrentThread.ManagedThreadId, i));
var finaliser2 = PipeLine.Create <int, int>(i => i * 5).Next(i => Console.WriteLine("2 - {0} {1}", Thread.CurrentThread.ManagedThreadId, i));
await PipeLine.Create <int, int>(a => a * 2).Next(finaliser1, finaliser2).Consume(1);
}
public async Task Composition5()
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
var finaliser = PipeLine.Create <int>(i => Console.WriteLine("{0} {1}", Thread.CurrentThread.ManagedThreadId, i));
await PipeLine.Create <int, int>(a => a * 2).Next(a => a - 2).Next(finaliser).Consume(25);
await finaliser.Consume(40);
}
public async Task Composition()
{
var trans = Transformer.Create <int, int>(a => a * 2);
var print = Consumer.Create <int>(Console.WriteLine);
var pip = PipeLine.Create(trans);
var final = pip.Next(print);
await final.Consume(25);
}
public async Task Create_Should_Compute_Result_OK(int iin, int iout)
{
var current = Thread.CurrentThread;
var pip = PipeLine.Create(_Func.Function).Next(_Act.Action);
await pip.Consume(iin);
_Func.LastIn.Should().Be(iin);
_Func.LastOut.Should().Be(iout);
_Func.CallingThread.Should().NotBe(current);
_Act.CallingThread.Should().NotBe(current);
_Act.CallingThread.Should().NotBe(_Func.CallingThread);
}
public async Task Create_Action_With_Paralelism_Parameter_Should_Compute_Result_OK()
{
var current = Thread.CurrentThread;
var pipe = PipeLine.Create(_Act3.Action, 5);
await Task.WhenAll(Enumerable.Range(0, 100).Select(i => pipe.Consume(i)));
_Act3.Threads.Count.Should().Be(5);
_Act3.Threads.Should().NotContain(_Func4.CallingThread);
_Act3.Threads.Should().NotContain(current);
}
public async Task Composition8()
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
var finaliser1 = PipeLine.Create <int>(i => Console.WriteLine("{0} {1}", Thread.CurrentThread.ManagedThreadId, i));
Func <int, int> M3 = i => { Thread.Sleep(500); Console.WriteLine("M3 Thread:{0} (5 threads)", Thread.CurrentThread.ManagedThreadId); return(i * 3); };
Func <int, int> M5 = i => { Console.WriteLine("M5 Thread:{0} (monothreaded)", Thread.CurrentThread.ManagedThreadId); return(i * 5); };
var pip1 = PipeLine.Create(M3, 5).Next(finaliser1);
var pip2 = PipeLine.Create(M5).Next(finaliser1);
var pipe = PipeLine.Create <int, int>(a => a * 2).Next(pip1, pip2);
await Task.WhenAll(Enumerable.Range(0, 100).Select(i => pipe.Consume(i)));
}
public async Task Composition7()
{
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
var finaliser1 = PipeLine.Create <int>(i => Console.WriteLine("{0} {1}", Thread.CurrentThread.ManagedThreadId, i));
Func <int, int> M3 = i => { Console.WriteLine("M3 {0}", Thread.CurrentThread.ManagedThreadId); return(i * 3); };
Func <int, int> M5 = i => { Console.WriteLine("M5 {0}", Thread.CurrentThread.ManagedThreadId); return(i * 5); };
var pip1 = PipeLine.Create <int, int>(M3).Next(finaliser1);
var pip2 = PipeLine.Create <int, int>(M5).Next(finaliser1);
var pip = PipeLine.Create <int, int>(a => a * 2).Next(pip1, pip2);
await pip.Consume(1);
await pip.Consume(10);
}
public void Connect_Should_Compute_Result_OK()
{
var current = Thread.CurrentThread;
var pipe = PipeLine.Create(_Func.Function).Next(_Act.Action);
var obs = Observable.Range(0, 100);
var res = Enumerable.Range(0, 100).Select(_Func.Function);
var disp = pipe.Connect(obs);
Thread.Sleep(10);
_Act.Threads.Count.Should().Be(1);
_Act.Results.Should().BeEquivalentTo(res);
disp.Dispose();
}
public async Task Compose_Parralel_Should_Compute_Result_OK_NoParameter()
{
var current = Thread.CurrentThread;
var fin = PipeLine.Create(_Act.Action);
var pip1 = PipeLine.Create(_Func.Function).Next(fin);
var pip2 = PipeLine.Create(_Func2.Function).Next(fin);
var pip = PipeLine.Create <int, int>(a => a * 2).Next(pip1, pip2);
await pip.Consume(1);
_Act.Threads.Count.Should().Be(1);
_Act.CallingThread.Should().NotBe(current);
_Act.CallingThread.Should().NotBe(_Func.CallingThread);
_Act.CallingThread.Should().NotBe(_Func2.CallingThread);
}
public async Task Compose_Parralel_Should_Compute_Result_OK(int entry, int s1, int s2)
{
var current = Thread.CurrentThread;
var finaliser1 = PipeLine.Create(_Func.Function).Next(_Act.Action);
var finaliser2 = PipeLine.Create(_Func3.Function).Next(_Act2.Action);
await PipeLine.Create <int, int>(a => a).Next(finaliser1, finaliser2).Consume(entry);
_Func.LastIn.Should().Be(entry);
_Func.LastOut.Should().Be(s1);
_Func3.LastIn.Should().Be(entry);
_Func3.LastOut.Should().Be(s2);
_Func3.CallingThread.Should().NotBe(current);
_Func3.CallingThread.Should().NotBe(_Func.CallingThread);
_Func.CallingThread.Should().NotBe(current);
_Func.CallingThread.Should().NotBe(_Func3.CallingThread);
}
public async Task Composition3()
{
var pip = PipeLine.Create <int, int>(a => a * 2).Next(Console.WriteLine);
await pip.Consume(25);
}
public async Task Composition2()
{
var pip = PipeLine.Create <int, int>(a => a * 2);
var final = pip.Next(Console.WriteLine);
await final.Consume(25);
}
