protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting DUCK TYPE TEST");
var helloObject = new HelloClass();
var iHello = helloObject.ActAs <IHello>();
dynamic helloDynamic = new HelloDynamicObject();
var iHelloDynamic = ((object)helloDynamic).ActAs <IHello>();
helloObject.Test(Guid.NewGuid(), "ES");
iHello.Test(Guid.NewGuid(), "ES");
helloDynamic.Test(Guid.NewGuid(), "ES");
iHelloDynamic.Test(Guid.NewGuid(), "ES");
//
Core.Log.InfoBasic(helloObject.Suma(12, 12).ToString());
Core.Log.InfoBasic(iHello.Suma(12, 12).ToString());
Core.Log.InfoBasic(helloDynamic.Suma(12, 12).ToString());
Core.Log.InfoBasic(iHelloDynamic.Suma(12, 12).ToString());
for (var i = 0; i < 50; i++)
{
Core.Log.InfoBasic("Calling the object method");
helloObject.SayHello();
Core.Log.InfoBasic("Calling the interface method on static object");
iHello.SayHello();
Core.Log.InfoBasic("Calling the dynamic method");
helloDynamic.SayHello();
Core.Log.InfoBasic("Calling the interface method on dynamic object");
iHelloDynamic.SayHello();
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting HASH TEST");
var gId = Guid.NewGuid();
var gIdBytes = gId.ToByteArray();
Core.Log.InfoBasic("Guid: {0}", gId);
var sha1 = gIdBytes.GetHashSHA1();
Core.Log.InfoBasic("SHA1 {0}", sha1);
var sha256 = gIdBytes.GetHashSHA256();
Core.Log.InfoBasic("SHA256: {0}", sha256);
var sha384 = gIdBytes.GetHashSHA384();
Core.Log.InfoBasic("SHA384: {0}", sha384);
var sha512 = gIdBytes.GetHashSHA512();
Core.Log.InfoBasic("SHA512: {0}", sha512);
var md5 = gIdBytes.GetHashMD5();
Core.Log.InfoBasic("MD5: {0}", md5);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var instance1 = Core.Injector.New <IInjectTestA>("Default");
var instance2 = Core.Injector.New <IInjectTestA>("Default");
if (instance1 != instance2)
{
Core.Log.InfoBasic("The instance are differents. OK");
}
else
{
Core.Log.Error("The instance is the same. Error");
}
var guid1 = instance1.GetGuid();
var guid2 = instance2.GetGuid();
if (guid1 != guid2)
{
Core.Log.InfoBasic("The Guid are differents. OK");
}
else
{
Core.Log.Error("The Guid are the same. Error");
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting COMPRESSOR TEST");
Core.Log.InfoBasic("Generating Random Bytes");
var rnd = new Random();
var bytes = new byte[ushort.MaxValue * 2000];
for (var i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)rnd.Next(50, 60);
}
Core.Log.InfoBasic("Total Bytes = {0}", bytes.Length.ToReadableBytes());
Core.Log.InfoBasic("Creating GZip Compressor");
var gzipCompressor = CompressorManager.GetByEncodingType("gzip");
using (Watch.Create("GZIP COMPRESSOR"))
{
var gzipBytes = gzipCompressor.Compress(bytes);
Core.Log.InfoBasic("Total GZIP Bytes = {0} - {1:0.000}%", gzipBytes.Count.ToReadableBytes(), ((double)gzipBytes.Count * 100) / bytes.Length);
}
Core.Log.InfoBasic("Creating Deflate Compressor");
var deflateCompressor = CompressorManager.GetByEncodingType("deflate");
using (Watch.Create("DEFLATE COMPRESSOR"))
{
var deflateBytes = deflateCompressor.Compress(bytes);
Core.Log.InfoBasic("Total DEFLATE Bytes = {0} - {1:0.000}%", deflateBytes.Count.ToReadableBytes(), ((double)deflateBytes.Count * 100) / bytes.Length);
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var queues = Core.Services.GetDefaultQueuesConfiguration();
if (queues == null)
{
Core.Log.Warning("Nothing to do.");
return;
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Checking, Creating and settings permissions to the Queues:");
Core.Log.WriteEmptyLine();
foreach (var queue in queues.Items)
{
Core.Log.InfoBasic("Processing queue = {0}", queue.Name);
if (queue.Types.Admin.IsNotNullOrEmpty())
{
var manager = queue.GetQueueManager();
manager.CreateClientQueues();
manager.CreateServerQueues();
}
else
{
Core.Log.Warning("Queue was skipped because the Admin type wasn't found in the queues.xml");
}
Core.Log.WriteEmptyLine();
}
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.DebugMode = true;
Core.Log.Warning("Slack Bot Test");
Core.Log.InfoBasic("Please enter the Bot Token:");
var token = Console.ReadLine();
var slackTransport = new SlackBotTransport(token);
var botEngine = new BotEngine(slackTransport);
botEngine.Commands.Add(msg => msg.StartsWith("Hello"), (bot, message) =>
{
Core.Log.Warning(message.SerializeToJson());
bot.SendTextMessageAsync(message.Chat, "Message Received");
return(true);
});
Core.Log.Warning("Connecting...");
await botEngine.StartListenerAsync().ConfigureAwait(false);
Core.Log.Warning("Connected.");
Console.ReadLine();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting STATUS TEST");
var rootNodeOne = new Node {
Name = "Root Node 1", Value = "Root Value 1"
};
var rootNodeTwo = new Node {
Name = "Root Node 2", Value = "Root Value 2"
};
var nodeOne = new Node {
Name = "Node 1", Value = "Value 1"
};
var nodeTwo = new Node {
Name = "Node 2", Value = "Value 2"
};
var lst = new List <Node>();
var lst2 = new List <Node>();
var dct = new Dictionary <string, Node>();
//Core.Status.AttachChild(nodeOne, this);
Core.Status.AttachChild(nodeTwo, this);
Core.Status.AttachChild(lst, this);
Core.Status.AttachChild(lst2, this);
Core.Status.AttachObject(dct);
Core.Status.AttachChild(rootNodeOne, this);
Core.Status.AttachChild(nodeOne, rootNodeOne);
Console.ReadLine();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting WEAK TEST");
WeakSample();
Console.ReadLine();
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
var settings = Config.DeserializeFromXml <CacheSettings>();
Core.Services.SetDefaultCacheClientSettings(settings);
var cacheClient = await Core.Services.GetCacheClientAsync("Agsw.Services.Cache").ConfigureAwait(false);
var keys = await cacheClient.GetKeysAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Keys: {0}", keys.Length);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Lru2QStorageTest();
Core.Log.InfoBasic("Press ENTER to continue.");
Console.ReadLine();
FileStorageTest();
Core.Log.InfoBasic("Press ENTER to continue.");
Console.ReadLine();
CombinedTest();
Core.Log.InfoBasic("Press ENTER to exit.");
Console.ReadLine();
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
for (var i = 0; i < 100; i++)
{
Core.Log.Error("NUMBER: {0}", i);
await Task.WhenAll(
CacheSingleTest(),
CacheSingleTest()
).ConfigureAwait(false);
await Task.Delay(2000).ConfigureAwait(false);
}
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.DebugMode = false;
Core.Log.Warning("Starting CACHE Async TEST");
var cacheService = new TestCacheService();
cacheService.OnStart(null);
using (var cachePool = new CacheClientPoolAsync("Pool Test")
{
Serializer = GlobalSerializer, ForceAtLeastOneNetworkItemEnabled = false, WriteNetworkItemsToMemoryOnGet = true
})
{
var cacheClient = await CacheClientProxy.GetClientAsync(new DefaultTransportClient("127.0.0.1", 20051, 3, GlobalSerializer)).ConfigureAwait(false);
cachePool.Add("localhost:20051", cacheClient, StorageItemMode.ReadAndWrite);
//cachePool.Add("memory", new LRU2QStorage(2000), StorageItemMode.ReadAndWrite);
var res = await cachePool.GetMetaAsync("metaValue").ConfigureAwait(false);
await cachePool.GetKeysAsync().ConfigureAwait(false);
using (var watch = Watch.Create("GetKeysAsync"))
{
for (var i = 0; i < 1000; i++)
{
await cachePool.GetKeysAsync().ConfigureAwait(false);
}
Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 1000);
}
Console.ReadLine();
using (var watch = Watch.Create("Get And Sets"))
{
for (var i = 0; i < 5000; i++)
{
var key = "test-" + (i % 500);
await cachePool.GetAsync(key).ConfigureAwait(false);
await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false);
}
Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 5000);
}
}
cacheService.OnStop();
Console.ReadLine();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting Cache Timeout Collection Test");
var cacheTimeoutCollection = CacheTimeoutCollection <string, object> .CreateFromLRU2Q(100);
cacheTimeoutCollection.OnItemTimeout += CacheTimeoutCollection_OnItemTimeout;
cacheTimeoutCollection.OnRemovedByPaging += CacheTimeoutCollection_OnRemovedByPaging;
for (var i = 0; i < 1000; i++)
{
cacheTimeoutCollection.TryAdd("Key - " + i, null, TimeSpan.FromSeconds(5));
}
Task.Delay(10000).WaitAsync();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Thread.Sleep(1000);
Core.Log.Warning("Starting HIT TEST");
Run(0, 50_000, 10_000_000, 50_000);
Thread.Sleep(2000);
Core.Log.WriteEmptyLine();
Core.Log.WriteEmptyLine();
Core.Log.Warning("Starting INSERTION/DELETE TEST");
Run(0, 200_000_000, 10_000_000, 50_000);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting ENCRYPTION TEST");
var message = "Hola Mundo esto es una prueba de encriptación, espero que funcione";
var skp = new SymmetricKeyProvider();
Core.Log.InfoBasic(message);
var enc = skp.Encrypt(message, "password");
Core.Log.InfoBasic(enc);
var dec = skp.Decrypt(enc, "password");
Core.Log.InfoBasic(dec);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting String Hash Test");
var str = "Lorem ipsum dolor sit amet";
int number = 10_000_000;
int normalHash = 0;
uint superFastHash = 0;
uint murmurhash2 = 0;
uint murmurhash3 = 0;
str.GetHashCode();
str.GetSuperFastHash();
str.GetMurmurHash2();
str.GetMurmurHash3();
using (Watch.Create("Normal Hash - GetHashCode()"))
{
for (var i = 0; i < number; i++)
{
normalHash = (str + i).GetHashCode();
}
}
using (Watch.Create("Superfast Hash - GetSuperFastHash()"))
{
for (var i = 0; i < number; i++)
{
superFastHash = (str + i).GetSuperFastHash();
}
}
using (Watch.Create("MurmurHash2 Hash - GetMurmurHash2()"))
{
for (var i = 0; i < number; i++)
{
murmurhash2 = (str + i).GetMurmurHash2();
}
}
using (Watch.Create("MurmurHash3 Hash - GetMurmurHash3()"))
{
for (var i = 0; i < number; i++)
{
murmurhash3 = (str + i).GetMurmurHash3();
}
}
Core.Log.InfoBasic("Normal Hash: {0}", normalHash);
Core.Log.InfoBasic("Superfast Hash: {0}", superFastHash);
Core.Log.InfoBasic("MurmurHash2 Hash: {0}", murmurhash2);
Core.Log.InfoBasic("MurmurHash3 Hash: {0}", murmurhash3);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var consumer = new AsyncConsumerEnumerable <string>
{
Task.Run(() => "Hola"),
Task.Delay(5000).ContinueWith(t => "Esperó 5 segundos"),
Task.Delay(2000).ContinueWith(t => "Mundo (tenia una espera de 2 pero ya se habia cumplido)"),
Task.Run(() => new[] { "Tambien", "Soporto", "Arrays" })
};
foreach (var c in consumer)
{
Console.WriteLine(c);
}
Console.ReadLine();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var n2obj1 = Core.Injector.New <IInjectTestA>("Default");
var n2obj2 = Core.Injector.New <IInjectTestB>("Default");
var instance1 = Core.Injector.New <IInjectTestA>("Default");
var instance2 = Core.Injector.New <IInjectTestA>("Default");
var times = 10_000_000;
Core.Log.InfoBasic("Injector Number of times: {0}", times);
using (var w = Watch.Create("Injector Object A"))
for (var i = 0; i < times; i++)
{
Core.Injector.New <IInjectTestA>("Default");
}
using (var w = Watch.Create("Injector Object B"))
for (var i = 0; i < times; i++)
{
Core.Injector.New <IInjectTestB>("Default");
}
if (instance1 != instance2)
{
Core.Log.InfoBasic("The instance are differents. OK");
}
else
{
Core.Log.Error("The instance is the same. Error");
}
var guid1 = instance1.GetGuid();
var guid2 = instance2.GetGuid();
if (guid1 != guid2)
{
Core.Log.InfoBasic("The Guid are differents. OK");
}
else
{
Core.Log.Error("The Guid are the same. Error");
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting HTTP TEST");
info.Service = new TaskService(async token =>
{
var server = new SimpleHttpServer()
.AddGetHandler("/", context =>
{
context.Response.WriteLine("Hola Mundo");
})
.AddHttpControllerRoutes <MyController>();
await server.StartAsync(8085).ConfigureAwait(false);
Core.Log.InfoBasic("Listening to port 8085");
await Task.Run(() => token.WaitHandle.WaitOne(), token).ConfigureAwait(false);
await server.StopAsync().ConfigureAwait(false);
});
info.ShouldEndExecution = false;
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
var serializer = new NBinarySerializer();
var service = new SampleProvider();
Core.Log.InfoBasic("Setting RPC Server");
var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer));
rpcServer.AddService(typeof(ISampleProvider), service);
await rpcServer.StartAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Setting RPC Client");
var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer));
var hClient = await rpcClient.CreateDynamicProxyAsync <ISampleProvider>().ConfigureAwait(false);
var client = hClient.ActAs <ISampleProvider>();
Core.Log.InfoBasic("GetSampleAsync");
var sampleTsk = await client.GetSampleAsync().ConfigureAwait(false);
Core.Log.InfoBasic("DelayTestAsync");
await client.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample = client.GetSample();
Core.Log.InfoBasic("GetSample as Async");
var sampleSimAsync = ((dynamic)hClient).GetSample2Async().Result;
var pClient = await rpcClient.CreateProxyAsync <SampleProxy>().ConfigureAwait(false);
Core.Log.InfoBasic("GetSampleAsync");
var sampleTsk2 = await pClient.GetSampleAsync().ConfigureAwait(false);
Core.Log.InfoBasic("DelayTestAsync");
await pClient.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample2 = pClient.GetSample();
rpcClient.Dispose();
await rpcServer.StopAsync().ConfigureAwait(false);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var consumer = new ProducerConsumerEnumerable <string>(async(producer, token) =>
{
for (var i = 0; i < 2500; i++)
{
producer.Add("Valor: " + i);
await Task.Delay(1, token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
await consumer.ForEachAsync(value =>
{
Console.WriteLine(value);
}).ConfigureAwait(false);
Console.WriteLine("Async Finished 1");
});
Task.Run(async() =>
{
await consumer.ForEachAsync(value =>
{
Console.WriteLine(value);
}).ConfigureAwait(false);
Console.WriteLine("Async Finished 2");
});
Task.Run(async() =>
{
await consumer.ForEachAsync(value =>
{
Console.WriteLine(value);
}).ConfigureAwait(false);
Console.WriteLine("Async Finished 3");
});
Console.ReadLine();
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
try
{
Core.Log.Warning("Starting BROWSER EMULATOR TEST");
var be = new BrowserEmulator();
Core.Log.Verbose("Getting: www.google.com");
var br = await be.NavigateAsync(new BrowserRequest { RequestUrl = "http://www.google.com" }).ConfigureAwait(false);
var response = Encoding.UTF8.GetString(br.Content);
Core.Log.Verbose("Results:");
Core.Log.InfoBasic(response);
Core.Log.InfoBasic("END");
}
catch (Exception ex)
{
Core.Log.Write(ex);
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting SQL Server Test");
IDalCity dalCity = new DalCity();
using (Watch.Create("Sync Test"))
{
for (var i = 0; i < 30; i++)
{
using (var w = Watch.Create())
{
var values = dalCity.GetAll();
w.Tap("GetAll");
var arr = values.ToArray();
w.Tap($"Entity Binding: {arr.Length} items");
}
}
}
Console.ReadLine();
Task.Run(async() =>
{
using (Watch.Create("Async Test"))
{
for (var i = 0; i < 30; i++)
{
using (var w = Watch.Create())
{
var values = await dalCity.GetAllAsync().ConfigureAwait(false);
w.Tap("GetAll");
var arr = values.ToArray();
w.Tap($"Entity Binding: {arr.Length} items");
}
}
}
});
Console.ReadLine();
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting MemoryQueue Test");
#region Set Config
var mqConfig = GetConfig();
#endregion
JsonTextSerializerExtensions.Serializer.Indent = true;
mqConfig.SerializeToXmlFile("memoryqConfig.xml");
mqConfig.SerializeToJsonFile("memoryqConfig.json");
var manager = mqConfig.GetQueueManager();
manager.CreateClientQueues();
//Core.DebugMode = true;
//Core.Log.MaxLogLevel = Diagnostics.Log.LogLevel.InfoDetail;
Core.Log.Warning("Starting with Normal Listener and Client");
await NormalTest(mqConfig).ConfigureAwait(false);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var lstMetadatas = new KeyValue[]
{
new KeyValue("Key01", "Value01"),
new KeyValue("Key02", "Value02"),
new KeyValue("Key01", "Value01 - New Value"),
new KeyValue("Key02", "Value02 - New Value"),
new KeyValue("Key03", "Value03")
};
var mergeEnumerable = lstMetadatas.Merge(item => item.Key, values =>
{
return(new KeyValue(values.First().Key, string.Join(", ", values.Select(v => v.Value))));
});
var mergeList = mergeEnumerable.ToList();
foreach (var keyValue in mergeList)
{
Console.WriteLine($"Key = {keyValue.Key}, Value = {keyValue.Value}");
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting Serializer TEST");
if (info.Arguments?.Contains("/complex") == true)
{
var file = "c:\\temp\\complex.test.nbin.gz";
var serializer = SerializerManager.GetByFileName(file);
AssemblyResolverManager.RegisterDomain(new[] { @"C:\AGSW_GIT\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" });
//AssemblyResolverManager.RegisterDomain(new[] { @"C:\Repo\AgswGit\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" });
object value = null;
try
{
value = serializer.DeserializeFromFile <object>(file);
//value = rMsg.Body.GetValue();
}
catch (DeserializerException exGO)
{
var jsonSerializer = new JsonTextSerializer {
Indent = true
};
jsonSerializer.SerializeToFile(exGO.Value, "c:\\temp\\complexObject-GenericObject.json");
var val = exGO.Value["Products"][5];
}
RunTestEx(value, 500, null);
//GC.Collect();
//GC.WaitForFullGCComplete();
//RunTestEx(value, 200, new GZipCompressor());
//GC.Collect();
//GC.WaitForFullGCComplete();
//RunTestEx(value, 200, new DeflateCompressor());
return;
}
var sTest = new STest
{
FirstName = "Daniel",
LastName = "Redondo",
Age = 33,
value = 166
};
var collection = new List <List <STest> >();
for (var i = 0; i <= 10; i++)
{
var colSTest = new List <STest>
{
sTest, sTest, sTest, sTest, sTest, sTest,
sTest, sTest, sTest, sTest, sTest, sTest,
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 0, Age = 1, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 1, Age = 2, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 2, Age = 3, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 3, Age = 4, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 4, Age = 5, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 5, Age = 6, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 6, Age = 7, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 7, Age = 8, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 8, Age = 9, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 9, Age = 10, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 10, Age = 11
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 11, Age = 12
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 12, Age = 13
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 13, Age = 14
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 14, Age = 15
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 15, Age = 16
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 16, Age = 17
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 17, Age = 18
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 18, Age = 19
},
//new STest2 { FirstName = "Person" , LastName = "Person" + i + "." + i+19, Age = 20, New = "This is a test" }
};
collection.Add(colSTest);
}
var lt = new List <STest>
{
new STest {
FirstName = "Name1", LastName = "LName1", Age = 11
},
//new STest2 { FirstName = "Name2" , LastName = "LName2", Age = 20, New = "This is a test" }
};
var lt2 = new List <Test3>
{
new Test3 {
Values = new List <int> {
2, 3, 4, 5
}
},
new Test3 {
Values = new List <int> {
10, 11, 12, 13
}
}
};
var dct = new Dictionary <string, int>
{
["Value1"] = 1,
["Value2"] = 2,
["Value3"] = 3,
};
var colClone = collection[0].DeepClone();
var clone = collection.DeepClone();
if (info.Arguments?.Contains("/parallel") == true)
{
RunSingleTest(collection[0], 2, false);
Core.Log.InfoBasic("Press ENTER to Start:");
Console.ReadLine();
Task.WaitAll(
Enumerable.Range(0, 8).Select(i => Task.Run(() => RunSingleTest(collection[0], 200_000, false))).ToArray()
);
Console.ReadLine();
return;
}
RunTest(collection[0], 200_000, false);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting Redis Test");
#region Set Config
var mqConfig = new MQPairConfig
{
Name = "QueueTest",
Types = new MQObjectTypes {
ClientType = typeof(RedisQueueClient), ServerType = typeof(RedisQueueServer)
},
RawTypes = new MQObjectTypes {
ClientType = typeof(RedisQueueRawClient), ServerType = typeof(RedisQueueRawServer)
},
ClientQueues = new List <MQClientQueues>
{
new MQClientQueues
{
EnvironmentName = "",
MachineName = "",
SendQueues = new List <MQConnection> {
new MQConnection("localhost", "TEST_RQ", null)
},
RecvQueue = new MQConnection("localhost", "TEST_RS", null)
}
},
ServerQueues = new List <MQServerQueues>
{
new MQServerQueues
{
EnvironmentName = "",
MachineName = "",
RecvQueues = new List <MQConnection> {
new MQConnection("localhost", "TEST_RQ", null)
}
}
},
RequestOptions = new MQRequestOptions
{
SerializerMimeType = SerializerManager.DefaultBinarySerializer.MimeTypes[0],
//CompressorEncodingType = "gzip",
ClientSenderOptions = new MQClientSenderOptions
{
Label = "TEST REQUEST",
MessageExpirationInSec = 30,
MessagePriority = MQMessagePriority.Normal,
Recoverable = false
},
ServerReceiverOptions = new MQServerReceiverOptions
{
MaxSimultaneousMessagesPerQueue = 20000,
ProcessingWaitOnFinalizeInSec = 10,
SleepOnExceptionInSec = 1000
}
},
ResponseOptions = new MQResponseOptions
{
SerializerMimeType = SerializerManager.DefaultBinarySerializer.MimeTypes[0],
//CompressorEncodingType = "gzip",
ClientReceiverOptions = new MQClientReceiverOptions(60,
new KeyValue <string, string>("SingleResponseQueue", "true")
),
ServerSenderOptions = new MQServerSenderOptions
{
Label = "TEST RESPONSE",
MessageExpirationInSec = 30,
MessagePriority = MQMessagePriority.Normal,
Recoverable = false
}
}
};
#endregion
JsonTextSerializerExtensions.Serializer.Indent = true;
mqConfig.SerializeToXmlFile("redisConfig.xml");
mqConfig.SerializeToJsonFile("redisConfig.json");
var manager = mqConfig.GetQueueManager();
manager.CreateClientQueues();
//Core.DebugMode = true;
//Core.Log.MaxLogLevel = Diagnostics.Log.LogLevel.InfoDetail;
Core.Log.Warning("Starting with Normal Listener and Client");
NormalTest(mqConfig);
mqConfig.ResponseOptions.ClientReceiverOptions.Parameters["SingleResponseQueue"] = "true";
Core.Log.Warning("Starting with RAW Listener and Client");
RawTest(mqConfig);
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
var serializer = new NBinarySerializer();
var service = new SampleProvider();
Core.Log.InfoBasic("Setting RPC Server");
var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer));
rpcServer.AddService(typeof(ISampleProvider), service);
await rpcServer.StartAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Setting RPC Client");
var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer));
var hClient = await rpcClient.CreateDynamicProxyAsync <ISampleProvider>().ConfigureAwait(false);
var client = hClient.ActAs <ISampleProvider>();
double perItemMs;
try
{
var intEnumerable = await client.GetInt().ConfigureAwait(false);
}
catch (Exception ex)
{
Core.Log.Write(ex);
}
using (var watch = Watch.Create("GetSampleAsync"))
{
Sample res;
for (var i = 0; i < 100000; i++)
{
res = await client.GetSampleAsync().ConfigureAwait(false);
}
perItemMs = watch.GlobalElapsedMilliseconds / 100000;
}
Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms");
Console.ReadLine();
Core.Log.InfoBasic("DelayTestAsync");
await client.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample = client.GetSample();
Core.Log.InfoBasic("GetSample as Async");
var sampleSimAsync = ((dynamic)hClient).GetSample2Async().Result;
Console.ReadLine();
var pClient = await rpcClient.CreateProxyAsync <SampleProxy>().ConfigureAwait(false);
using (var watch = Watch.Create("GetSampleAsync"))
{
Sample res;
for (var i = 0; i < 100000; i++)
{
res = await pClient.GetSampleAsync().ConfigureAwait(false);
}
perItemMs = watch.GlobalElapsedMilliseconds / 100000;
}
Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms");
Console.ReadLine();
Core.Log.InfoBasic("DelayTestAsync");
await pClient.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample2 = pClient.GetSample();
rpcClient.Dispose();
await rpcServer.StopAsync().ConfigureAwait(false);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting MEMORY STREAMS TEST");
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start RecycleMemoryStream Test.");
Console.ReadLine();
var xbuffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
using (Watch.Create("RecycleMemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new RecycleMemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (int i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (int i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start MemoryStream Test.");
Console.ReadLine();
using (Watch.Create("MemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new MemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (var i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (var i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start CircularBufferStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var cbs = new CircularBufferStream(50))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
cts.Cancel();
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start SharedMemoryStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var sharedms = new SharedMemoryStream("test", 2000))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
}
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.DebugMode = true;
Core.Log.Warning("Starting CACHE TEST");
var cacheService = new TestCacheService();
cacheService.OnStart(null);
using (var cachePool = new CacheClientPoolAsync("Pool Test")
{
Serializer = GlobalSerializer
})
{
var cacheClient = await CacheClientProxy.GetClientAsync(new DefaultTransportClient("127.0.0.1", 20051, 3, GlobalSerializer)).ConfigureAwait(false);
cachePool.Add("localhost:20051", cacheClient, StorageItemMode.ReadAndWrite);
await cachePool.SetAsync("expTest", "testData", TimeSpan.FromSeconds(20), new[] { "test" }).ConfigureAwait(false);
Console.ReadLine();
var asto = await cachePool.GetAsync("test").ConfigureAwait(false);
if (asto is null)
{
await cachePool.SetAsync("test", "value").ConfigureAwait(false);
asto = await cachePool.GetAsync("test").ConfigureAwait(false);
}
var guid = Guid.NewGuid();
await cachePool.CopyAsync("test", guid.ToString("N")).ConfigureAwait(false);
var asto2 = await cachePool.GetAsync(guid.ToString("N")).ConfigureAwait(false);
var guid2 = Guid.NewGuid();
await cachePool.CopyAsync("test", guid2.ToString("N")).ConfigureAwait(false);
var asto3 = await cachePool.GetAsync(guid2.ToString("N")).ConfigureAwait(false);
var guid3 = Guid.NewGuid();
await cachePool.CopyAsync("test", guid3.ToString("N")).ConfigureAwait(false);
var asto4 = await cachePool.GetAsync(guid3.ToString("N")).ConfigureAwait(false);
Console.ReadLine();
var tagValue1 = await cachePool.GetByTagAsync(new [] { "test" }).ConfigureAwait(false);
await Task.Delay(600).ConfigureAwait(false);
var tagValue2 = await cachePool.GetByTagAsync(new [] { "test" }).ConfigureAwait(false);
await Task.Delay(600).ConfigureAwait(false);
await cachePool.SetAsync("expTest2", "testData2", TimeSpan.FromMinutes(1), new[] { "test" }).ConfigureAwait(false);
await Task.Delay(600).ConfigureAwait(false);
var tagValue3 = await cachePool.GetByTagAsync(new[] { "test" }).ConfigureAwait(false);
await Task.Delay(600).ConfigureAwait(false);
var tagValue4 = await cachePool.SetMultiAsync(new[] { "testa", "testb" }, "Hola mundo", TimeSpan.FromSeconds(10)).ConfigureAwait(false);
await Task.Delay(600).ConfigureAwait(false);
var response = await cachePool.ExecuteExtensionAsync("SampleExtension", "Echo", new object[] { "value1", "value2" });
Core.Log.Warning("Extension Response: {0}", response);
Console.ReadLine();
try
{
for (var i = 0; i < 15; i++)
{
await cachePool.GetKeysAsync().ConfigureAwait(false);
}
Console.ReadLine();
for (var i = 0; i < 100; i++)
{
var key = "test-" + i;
await cachePool.GetAsync(key).ConfigureAwait(false);
await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false);
}
Console.ReadLine();
for (var i = 0; i < 100; i++)
{
var key = "test-" + i;
await cachePool.GetAsync(key).ConfigureAwait(false);
await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false);
}
}
catch (Exception ex)
{
Core.Log.Write(ex);
}
}
cacheService.OnStop();
}
