public void GetSingletone()
{
var resolver = new Resolver();
resolver.LoadFromReference <ResolverTests>();
var toResolve = resolver.CreateSession().Resolve <ToResolve2>();
Assert.IsNotNull(toResolve);
toResolve.Index = 2;
toResolve = resolver.CreateSession().Resolve <ToResolve2>();
Assert.IsNotNull(toResolve);
Assert.AreEqual(2, toResolve.Index);
}
public async Task CalculatorAddDuoTest()
{
var handlerProvider = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handlerProvider.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
//var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" });
var value = await handlerProvider.HandleAsync <CalculatorResult>(resolver.CreateSession(), "", 1,
new CalculatorArgument()
{
Left = 2, Right = 3
},
new CalculatorArgument()
{
Left = 4, Right = 5
});
var result = (CalculatorResult)value;
Assert.AreEqual(24, result.Result);
}
public void GetFromParent()
{
var parent = new Resolver();
var resolver = new Resolver(parent);
parent.LoadFromReference <ResolverTests>();
var toResolve = resolver.ResolveSingletone <ToResolve2>();
Assert.IsNotNull(toResolve);
toResolve.Index = 5;
toResolve = parent.ResolveSingletone <ToResolve2>();
Assert.IsNotNull(toResolve);
Assert.AreEqual(5, toResolve.Index);
toResolve = parent.CreateSession().Resolve <ToResolve2>();
Assert.IsNotNull(toResolve);
Assert.AreEqual(5, toResolve.Index);
toResolve = resolver.CreateSession().Resolve <ToResolve2>();
Assert.IsNotNull(toResolve);
Assert.AreEqual(5, toResolve.Index);
}
public async Task HandleManySum()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
var watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
//var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 });
//var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 });
var value = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), 1, new object[] {
new CalculatorArgument()
{
Left = 2, Right = 3
},
});
}
watch.Stop();
// s: 100k 0.59s
}
public async Task HandleSumThree()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] {
new IntArgument()
{
Left = 2, Right = 3
},
new IntArgument()
{
Left = 4, Right = 5
},
new ByteArgument {
Left = 6, Right = 7
}
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == (2 + 3 + 4 + 5 + 6 + 7));
}
public IResolverSession GetProtocolResolver(IPacketStream packetStream, CancellationToken cancellationToken)
{
var resolver = new Resolver();
resolver.LoadFromReference <ProtocolTests>();
var session = resolver.CreateSession();
var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>());
handler.LoadFromReference <ProtocolTests>();
var converter = new Serializer();
converter.LoadFromReference <ProtocolTests>();
var protocol = new SocketProtocolHandler(session, packetStream, converter, handler);
session.Resolver.Register(protocol);
session.Resolver.Register(handler);
session.Resolver.Register(converter);
var listenTask = protocol.ListenAsync(cancellationToken);
return(session);
}
public void GetInheritThrow()
{
var resolver = new Resolver();
resolver.LoadFromReference <ResolverTests>();
var toResolve = resolver.CreateSession().Resolve <NotIncludedResolve>();
Assert.IsNotNull(toResolve);
Assert.IsInstanceOfType(toResolve, typeof(ToResolve4));
}
public void CreateInstance()
{
var resolver = new Resolver();
resolver.LoadFromReference <ResolverTests>();
var toResolve = resolver.CreateSession().CreateInstance <ToResolve>();
Assert.IsNotNull(toResolve);
Assert.IsNotNull(toResolve.Resolver);
Assert.IsNotNull(toResolve.ToResolve2);
Assert.IsNotNull(toResolve.ToResolve2.Resolver);
Assert.IsNotNull(toResolve.ToResolve2.ToResolve4);
}
public async Task HandleSumString()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <string>(resolver.CreateSession(), 0, "s");
Assert.IsNotNull(result);
Assert.IsTrue(result is string);
Assert.IsTrue((string)result == "sums");
}
public async Task HandleSumZero()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] { });
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == 1);
}
public async Task SumInterfaceHandlingFromResolver()
{
Resolver resolver = new Resolver();
resolver.LoadFromReference <InterfaceHandlingTests>();
resolver.Register(new HandlerArgument()
{
Arg = "5"
});
var sum = resolver.CreateSession().CreateHandler <ISum, InterfaceHandlerTest <ISum> >();
var value = await sum.Sum("opa", "o");
Assert.AreEqual("Sumopao5", value);
}
public void DisposeNotSingletoneWithNotSingletone()
{
var resolver = new Resolver();
resolver.LoadFromReference <ResolverTests>();
ToResolve3 toResolve;
using (var session = resolver.CreateSession())
{
toResolve = session.Resolve <ToResolve3>();
}
Assert.IsTrue(toResolve.IsDisposed);
Assert.IsTrue(toResolve.ToResolve4.IsDisposed);
resolver.Dispose();
}
public async Task HandleMinusAsyncWithRole()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new IntArgument()
{
Left = 2, Right = 3
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == -1);
}
public async Task CalculatorAddStringTest()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
//var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" });
var result = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), "IAddString", 1, "6");
Assert.AreEqual(7, result.Result);
}
public async Task <IResolverSession> StartClientAsync(string host, int port, CancellationToken cancellationToken)
{
if (!loaded)
{
throw new Exception($"Call InitializeFromReference first");
}
var client = new TcpClient();
var session = Resolver.CreateSession();
session.Resolver.Register(client, false);
session.Resolver.AddDisposable(client);
await client.ConnectAsync(host, port);
ClientListenAsync(client, session, true, cancellationToken);
return(session);
}
public async Task StartServerAsync(string ipString, int port, CancellationToken cancellationToken)
{
if (!loaded)
{
throw new Exception($"Call InitializeFromReference first");
}
var ipAddress = IPAddress.Parse(ipString);
var listener = new TcpListener(ipAddress, port);
listener.Start();
try
{
using (var register = cancellationToken.Register(() => listener.Stop()))
{
do
{
var client = await listener.AcceptTcpClientAsync();
try
{
var session = Resolver.CreateSession();
session.Resolver.Register(client, false);
session.Resolver.AddDisposable(client);
ClientListenAsync(client, session, false, cancellationToken);
}
catch
{
try
{
client.Dispose();
}
catch { };
}
} while (!cancellationToken.IsCancellationRequested);
}
}
finally
{
listener.Stop();
}
}
public void CreateManyInstanceManySession()
{
var resolver = new Resolver();
resolver.LoadFromReference <ResolverTests>();
Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
using (var session = resolver.CreateSession())
{
var toResolve = session.CreateInstance <ToResolve>();
}
}
resolver.Dispose();
watch.Stop();
}
public async Task HandleManyMultiplyAsync()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 1, new IntArgument()
{
Left = 2, Right = 3
});
}
watch.Stop();
// 0.48s (0.8) 100k
}
public async Task HandlerByteMinusAsyncWithAdminMinusRoles()
{
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
var handler = new HandlerProvider();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new Roles("Minus", "Admin"));
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new ByteArgument()
{
Left = 6, Right = 2
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == 3);
}
public async Task InterfaceToMethodProtocolHandlerTest()
{
var resolver = new Resolver();
resolver.LoadFromReference <ProtocolTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
var session = resolver.CreateSession();
//resolver.Register(session);
var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>());
handler.LoadFromReference <ProtocolTests>();
var methodHandler = new MethodProtocolHandler(handler, session);
resolver.Register(methodHandler, true);
var calculator = InterfaceHandling.CreateHandler <ICalculator, ProtocolInterfaceHandler <ICalculator> >(session);
List <Task> tasks = new List <Task>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
var task = calculator.AddAsync("20");
tasks.Add(task);
}
await Task.WhenAll(tasks);
watch.Stop();
// a: 10k 0.2-0.3s
//Assert.AreEqual(30, task.Result);
}
public async Task SumInterfaceHandlingMany()
{
Resolver resolver = new Resolver();
resolver.LoadFromReference <InterfaceHandlingTests>();
resolver.Register(new HandlerArgument()
{
Arg = "5"
});
var sum = InterfaceHandling.CreateHandler <ISum, InterfaceHandlerTest <ISum> >(resolver.CreateSession());
var watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
var value = await sum.Sum("opa", "o");
}
watch.Stop();
// 100k 0.17s
}
