public void AddMoreThanCapacity()
{
EvictionQueue queue = new EvictionQueue();
queue.Capacity = 1000;
queue.EvictionCount = 100;
for (int i = 0; i < 10000; i++)
{
TradeLike item = new TradeLike(i, 1000 + i, "aaa", DateTime.Now, 456);
CachedObject packedItem = CachedObject.Pack(item);
queue.AddNew(packedItem);
}
Assert.IsTrue(queue.EvictionRequired);
Assert.AreEqual(queue.Count, 10000);
ICollection <CachedObject> evicted = queue.GO();
//should have removed 100 more than ( 10000 - 1000 )
Assert.AreEqual(queue.Count, 900);
Assert.IsFalse(queue.EvictionRequired);
Assert.AreEqual(evicted.Count, 9100);
//asking for eviction when bellow maximum capacity will not remove any item
evicted = queue.GO();
Assert.AreEqual(evicted.Count, 0);
}
public void Remove()
{
var schema = TypedSchemaFactory.FromType(typeof(TradeLike));
var queue = new EvictionQueue {
Capacity = 7, EvictionCount = 2
};
var allItems = new List <PackedObject>();
for (var i = 0; i < 10; i++)
{
var item = new TradeLike(i, 1000 + i, "aaa", DateTime.Now, 456);
var packedItem = PackedObject.Pack(item, schema);
queue.AddNew(packedItem);
allItems.Add(packedItem);
}
//items in queue now: 0 1 2 3 4 5 6 7 8 9
queue.TryRemove(allItems[0]);
queue.TryRemove(allItems[2]);
//items in queue now: 1 3 4 5 6 7 8 9
Assert.IsTrue(queue.EvictionRequired);
var evicted = queue.Go();
//items in queue now: 5 6 7 8 9
Assert.AreEqual(evicted.Count, 3);
Assert.AreEqual(evicted[0].PrimaryKey, 1);
Assert.AreEqual(evicted[1].PrimaryKey, 3);
}
public void Remove()
{
EvictionQueue queue = new EvictionQueue();
queue.Capacity = 7;
queue.EvictionCount = 2;
List <CachedObject> allItems = new List <CachedObject>();
for (int i = 0; i < 10; i++)
{
TradeLike item = new TradeLike(i, 1000 + i, "aaa", DateTime.Now, 456);
CachedObject packedItem = CachedObject.Pack(item);
queue.AddNew(packedItem);
allItems.Add(packedItem);
}
//items in queue now: 0 1 2 3 4 5 6 7 8 9
queue.TryRemove(allItems[0]);
queue.TryRemove(allItems[2]);
//items in queue now: 1 3 4 5 6 7 8 9
Assert.IsTrue(queue.EvictionRequired);
IList <CachedObject> evicted = queue.GO();
//items in queue now: 5 6 7 8 9
Assert.AreEqual(evicted.Count, 3);
Assert.AreEqual(evicted[0].PrimaryKey, 1);
Assert.AreEqual(evicted[1].PrimaryKey, 3);
}
public void AddMoreThanCapacity()
{
var schema = TypedSchemaFactory.FromType(typeof(TradeLike));
var queue = new EvictionQueue();
queue.Capacity = 1000;
queue.EvictionCount = 100;
for (var i = 0; i < 10000; i++)
{
var item = new TradeLike(i, 1000 + i, "aaa", DateTime.Now, 456);
var packedItem = PackedObject.Pack(item, schema);
queue.AddNew(packedItem);
}
Assert.IsTrue(queue.EvictionRequired);
Assert.AreEqual(queue.Count, 10000);
ICollection <PackedObject> evicted = queue.Go();
//should have removed 100 more than ( 10000 - 1000 )
Assert.AreEqual(queue.Count, 900);
Assert.IsFalse(queue.EvictionRequired);
Assert.AreEqual(evicted.Count, 9100);
//asking for eviction when bellow maximum capacity will not remove any item
evicted = queue.Go();
Assert.AreEqual(evicted.Count, 0);
}
public void TestProtobufEncoding()
{
QueryBuilder builder = new QueryBuilder(typeof(TradeLike));
KeyValue kval = builder.MakeKeyValue("Nominal", 0);
MemoryStream stream = new MemoryStream();
Serializer.Serialize(stream, kval);
stream.Seek(0, SeekOrigin.Begin);
KeyValue reloaded = Serializer.Deserialize <KeyValue>(stream);
Assert.AreEqual(kval, reloaded);
stream.Seek(0, SeekOrigin.Begin);
TradeLike obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), 0);
CachedObject packed = CachedObject.Pack(obj).Metadata;
Serializer.SerializeWithLengthPrefix(stream, packed, PrefixStyle.Fixed32);
Serializer.SerializeWithLengthPrefix(stream, packed, PrefixStyle.Fixed32);
stream.Seek(0, SeekOrigin.Begin);
CachedObject t1 = Serializer.DeserializeWithLengthPrefix <CachedObject>(stream, PrefixStyle.Fixed32);
Assert.AreEqual(t1.IndexKeys[2].ToString(), "#0");
CachedObject t2 = Serializer.DeserializeWithLengthPrefix <CachedObject>(stream, PrefixStyle.Fixed32);
Assert.AreEqual(t2.IndexKeys[2].ToString(), "#0");
}
public void TestProtobufEncoding()
{
var schema = TypedSchemaFactory.FromType(typeof(TradeLike));
var builder = new QueryBuilder(typeof(TradeLike));
var kval = new KeyValue(10, schema.KeyByName("Nominal"));
var stream = new MemoryStream();
Serializer.Serialize(stream, kval);
stream.Seek(0, SeekOrigin.Begin);
var reloaded = Serializer.Deserialize <KeyValue>(stream);
Assert.AreEqual(kval, reloaded);
stream.Seek(0, SeekOrigin.Begin);
var obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), 0);
var packed = PackedObject.Pack(obj, schema);
Serializer.SerializeWithLengthPrefix(stream, packed, PrefixStyle.Fixed32);
Serializer.SerializeWithLengthPrefix(stream, packed, PrefixStyle.Fixed32);
stream.Seek(0, SeekOrigin.Begin);
var t1 = Serializer.DeserializeWithLengthPrefix <PackedObject>(stream, PrefixStyle.Fixed32);
Assert.AreEqual(t1.Values[4].ToString(), "0");
var t2 = Serializer.DeserializeWithLengthPrefix <PackedObject>(stream, PrefixStyle.Fixed32);
Assert.AreEqual(t2.Values[4].ToString(), "0");
}
public void FeedAndGetMany()
{
//feed lots of objects to the cache
var session = _client.BeginFeed <TradeLike>(50, false);
var random = new Random();
for (var i = 0; i < 10000; i++)
{
var newItem = new TradeLike(i, 1000 + i, "aaa", new DateTime(2009, 10, 10), random.Next(1000));
_client.Add(session, newItem);
}
_client.EndFeed <TradeLike>(session);
//get a subset of the fed objects
var builder = new QueryBuilder(typeof(TradeLike));
var query = builder.GetMany("Nominal < 500");
//sync get
_client.GetMany <TradeLike>(query).ToList();
//async get
{
var evt = new ManualResetEvent(false);
var itemCount = 0;
_client.AsyncGetMany(query, delegate(TradeLike like, int item, int total)
{
itemCount++;
if (item == total)
{
evt.Set();
}
}, delegate { });
evt.WaitOne();
Console.WriteLine("Found {0} objects", itemCount);
}
//select
_logger.Reset();
var cmd = _parser.Parse("select TRADELIKE where Nominal < 500");
Assert.IsTrue(cmd.CanExecute);
Assert.IsNotNull(cmd.TryExecute(_client));
// check for empty result
_logger.Reset();
cmd = _parser.Parse("select TRADELIKE where Nominal < 500, Folder = inexistent");
Assert.IsTrue(cmd.CanExecute);
Assert.IsNotNull(cmd.TryExecute(_client));
}
public void AddTwiceRaisesAnException()
{
EvictionQueue queue = new EvictionQueue();
queue.Capacity = 1000;
queue.EvictionCount = 100;
TradeLike item = new TradeLike(0, 1000, "aaa", DateTime.Now, 456);
CachedObject packedItem = CachedObject.Pack(item);
queue.AddNew(packedItem);
//this call should raise an exception
Assert.Throws <NotSupportedException>(() => queue.AddNew(packedItem));
}
public void AddTwiceRaisesAnException()
{
var schema = TypedSchemaFactory.FromType(typeof(TradeLike));
var queue = new EvictionQueue {
Capacity = 1000, EvictionCount = 100
};
var item = new TradeLike(0, 1000, "aaa", DateTime.Now, 456);
var packedItem = PackedObject.Pack(item, schema);
queue.AddNew(packedItem);
//this call should raise an exception
Assert.Throws <NotSupportedException>(() => queue.AddNew(packedItem));
}
public void EvictionOrder()
{
EvictionQueue queue = new EvictionQueue();
queue.Capacity = 9;
queue.EvictionCount = 2;
List <CachedObject> allItems = new List <CachedObject>();
for (int i = 0; i < 10; i++)
{
TradeLike item = new TradeLike(i, 1000 + i, "aaa", DateTime.Now, 456);
CachedObject packedItem = CachedObject.Pack(item);
queue.AddNew(packedItem);
allItems.Add(packedItem);
}
//items in queue now: 0 1 2 3 4 5 6 7 8 9
Assert.IsTrue(queue.EvictionRequired);
IList <CachedObject> evicted = queue.Go();
//items in queue: 3 4 5 6 7 8 9
Assert.AreEqual(evicted.Count, 3);
Assert.AreEqual(evicted[0].PrimaryKey, 0);
Assert.AreEqual(evicted[1].PrimaryKey, 1);
queue.Touch(allItems[3]);
//items in queue: 4 5 6 7 8 9 3
queue.Touch(allItems[4]);
//items in queue: 5 6 7 8 9 3 4
queue.Capacity = 7;
evicted = queue.Go();
Assert.AreEqual(evicted.Count, 2);
Assert.AreEqual(evicted[0].PrimaryKey, 5);
Assert.AreEqual(evicted[1].PrimaryKey, 6);
}
public void FeedAndGetMany()
{
//feed lots of objects to the cache
var session = _client.BeginFeed <TradeLike>(50, false);
var random = new Random();
for (var i = 0; i < 10000; i++)
{
var newItem = new TradeLike(i, 1000 + i, "aaa", new DateTime(2009, 10, 10), random.Next(1000));
_client.Add(session, newItem);
}
_client.EndFeed <TradeLike>(session);
//get a subset of the fed objects
var builder = new QueryBuilder(typeof(TradeLike));
var query = builder.GetMany("Nominal < 500");
//sync get
_client.GetMany <TradeLike>(query).ToList();
//select
_logger.Reset();
var cmd = _parser.Parse("select TRADELIKE where Nominal < 500");
Assert.IsTrue(cmd.CanExecute);
Assert.IsNotNull(cmd.TryExecute(_client));
// check for empty result
_logger.Reset();
cmd = _parser.Parse("select TRADELIKE where Nominal < 500, Folder = inexistent");
Assert.IsTrue(cmd.CanExecute);
Assert.IsNotNull(cmd.TryExecute(_client));
}
public void SerializeCachedObjectUsingProtocolBuffers()
{
ClientSideTypeDescription.RegisterType(typeof(TradeLike));
Random randGen = new Random();
//to byte array
for (int i = 0; i < 5000; i++)
{
TradeLike obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), 1);
CachedObject packed = CachedObject.Pack(obj).Metadata;
byte[] data = SerializationHelper.ObjectToBytes(packed, SerializationMode.ProtocolBuffers, null);
CachedObject reloaded =
SerializationHelper.ObjectFromBytes <CachedObject>(data, SerializationMode.ProtocolBuffers, false);
Assert.AreEqual(reloaded.IndexKeys[2], packed.IndexKeys[2]);
Console.WriteLine(reloaded);
}
//to stream
MemoryStream stream = new MemoryStream();
List <CachedObject> items = new List <CachedObject>();
for (int i = 0; i < 1000; i++)
{
TradeLike obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), randGen.Next(1000));
CachedObject packed = CachedObject.Pack(obj).Metadata;
items.Add(packed);
}
List <CachedObject> itemsReloaded = new List <CachedObject>();
Streamer.ToStreamGeneric(stream, items);
stream.Seek(0, SeekOrigin.Begin);
ManualResetEvent evt = new ManualResetEvent(false);
Streamer.FromStream(stream,
delegate(CachedObject item, int i, int totalItems)
{
itemsReloaded.Add(item);
if (i == totalItems)
{
evt.Set();
}
},
delegate
{
/* ignore exceptions */
});
evt.WaitOne();
for (int i = 0; i < 1000; i++)
{
Assert.AreEqual(itemsReloaded[i].IndexKeys[2], items[i].IndexKeys[2]);
}
}
public void SerializeCachedObjectUsingProtocolBuffers()
{
var schema = TypedSchemaFactory.FromType(typeof(TradeLike));
var randGen = new Random();
//to byte array
for (var i = 0; i < 5000; i++)
{
var obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), 1);
var packed = PackedObject.Pack(obj, schema);
var data = SerializationHelper.ObjectToBytes(packed, SerializationMode.ProtocolBuffers, false);
var reloaded =
SerializationHelper.ObjectFromBytes <PackedObject>(data, SerializationMode.ProtocolBuffers, false);
Assert.AreEqual(reloaded.Values[2], packed.Values[2]);
Console.WriteLine(reloaded);
}
//to stream
var stream = new MemoryStream();
var items = new List <PackedObject>();
for (var i = 0; i < 1000; i++)
{
var obj = new TradeLike(1, 1001, "aaa", new DateTime(2009, 10, 10), randGen.Next(1000));
var packed = PackedObject.Pack(obj, schema);
items.Add(packed);
}
var itemsReloaded = new List <PackedObject>();
Streamer.ToStreamGeneric(stream, items);
stream.Seek(0, SeekOrigin.Begin);
var evt = new ManualResetEvent(false);
Streamer.FromStream(stream,
delegate(PackedObject item, int i, int totalItems)
{
itemsReloaded.Add(item);
if (i == totalItems)
{
evt.Set();
}
},
delegate
{
/* ignore exceptions */
});
evt.WaitOne();
for (var i = 0; i < 1000; i++)
{
Assert.AreEqual(itemsReloaded[i].Values[2], items[i].Values[2]);
}
}
