public static void ParseCommand(string input, IWriter output, BlobDatabase database) { var tokens = input.Split(' ').ToArray(); var commandType = tokens[0]; switch (commandType) { case "create": CreateCommand(database, tokens); break; case "attack": AttackCommand(database, tokens); break; case "pass": break; case "status": StatusCommand(output, database); break; case "report-events": //todo: report events break; default: throw new InvalidOperationException("Invalid Command."); } foreach (var blob in database) { if (blob.BlobBehavior.HasBeenTriggered) { blob.BlobBehavior.EndTurnAction(blob); } } }
static void Main() { IReader input = new ConsoleReader(); IWriter output = new ConsoleWriter(); BlobDatabase database = new BlobDatabase(); BlobEngine engine = new BlobEngine(database, input, output); engine.Run(); }
public async Task <BlobDBResponsePacket> Clear(BlobDatabase database) { var clearCommand = new BlobDBCommandPacket() { Token = GenerateToken(), Database = database, Command = BlobCommand.Clear }; return(await Send(clearCommand)); }
private static void ValidateLocalBlobDatabase(string blobDBpath, string installDirectory) { if (!BlobDatabase.ValidateBlobLocalDatabase(blobDBpath, installDirectory)) { Console.WriteLine("Could not get valid blob local database instance"); return; } Console.WriteLine("Valid local blob database instance found"); }
public void SavesUnsupportedTypes() { UnsupportedTypes item = null; var serializer = new BlobSerializerDelegate( obj => { if (obj is DateTimeOffset) { Assert.AreEqual(item.DateTimeOffset, obj); var offset = (DateTimeOffset)obj; var bytes = new byte[16]; Buffer.BlockCopy(BitConverter.GetBytes(offset.Ticks), 0, bytes, 0, 8); Buffer.BlockCopy(BitConverter.GetBytes(offset.Offset.Ticks), 0, bytes, 8, 8); return(bytes); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", obj.GetType())); }, (d, t) => { if (t == typeof(DateTimeOffset)) { var ticks = BitConverter.ToInt64(d, 0); var offset = BitConverter.ToInt64(d, 8); return(new DateTimeOffset(ticks, TimeSpan.FromTicks(offset))); } if (t == typeof(TimeSpan)) { return(TimeSpan.FromTicks(BitConverter.ToInt64(d, 0))); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", t)); }, t => true); using (var db = new BlobDatabase(serializer)) { db.CreateTable <UnsupportedTypes>(); item = new UnsupportedTypes() { Id = Guid.NewGuid(), DateTimeOffset = DateTime.Now }; db.Insert(item); var dbItem = db.Find <UnsupportedTypes>(item.Id); Assert.AreEqual(item.Id, dbItem.Id); Assert.AreEqual(item.DateTimeOffset, dbItem.DateTimeOffset); } }
public async Task <BlobDBResponsePacket> Delete(BlobDatabase database, byte[] key) { var deleteCommand = new BlobDBCommandPacket() { Token = GenerateToken(), Database = database, Command = BlobCommand.Delete, Key = key, }; return(await Send(deleteCommand)); }
public async Task <BlobDBResponsePacket> Insert(BlobDatabase database, byte[] key, byte[] value) { var insertCommand = new BlobDBCommandPacket() { Token = GenerateToken(), Database = database, Command = BlobCommand.Insert, Key = key, Value = value }; return(await Send(insertCommand)); }
public void SavesUnsupportedTypes() { UnsupportedTypes item = null; var serializer = new BlobSerializerDelegate( obj => { if (obj is DivideByZeroException) { var e = (DivideByZeroException)obj; var json = JsonConvert.SerializeObject(e); // subst your own serializer return(Encoding.UTF8.GetBytes(json)); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", obj.GetType())); }, (d, t) => { if (t == typeof(DivideByZeroException)) { var json = Encoding.UTF8.GetString(d); var result = JsonConvert.DeserializeObject <DivideByZeroException>(json); return(result); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", t)); }, t => true); using (var db = new BlobDatabase(serializer)) { db.CreateTable <UnsupportedTypes>(); item = new UnsupportedTypes() { Id = Guid.NewGuid(), DateTimeOffset = DateTime.Now, DivideByZeroException = new DivideByZeroException("a message") }; db.Insert(item); var dbItem = db.Find <UnsupportedTypes>(item.Id); Assert.AreEqual(item.Id, dbItem.Id); Assert.AreEqual(item.DateTimeOffset, dbItem.DateTimeOffset); //most db stores datetimeoffset as utc, forgetting the offset part. This one is not an exception. //TODO: test fails Assert.AreEqual(item.DateTimeOffset.Offset, dbItem.DateTimeOffset.Offset); //TODO: test fails Assert.AreEqual(item.DivideByZeroException.Message, dbItem.DivideByZeroException.Message); } }
public void SavesUnsupportedTypes() { UnsupportedTypes item = null; var serializer = new BlobSerializerDelegate( obj => { if (obj is DivideByZeroException) { var e = (DivideByZeroException)obj; var json = JsonConvert.SerializeObject(e); // subst your own serializer return(Encoding.UTF8.GetBytes(json)); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", obj.GetType())); }, (d, t) => { if (t == typeof(DivideByZeroException)) { #if __WINRT__ || WINDOWS_PHONE var json = Encoding.UTF8.GetString(d, 0, d.Length); #else var json = Encoding.UTF8.GetString(d); #endif var result = JsonConvert.DeserializeObject <DivideByZeroException>(json); return(result); } throw new InvalidOperationException(string.Format("Type {0} should not be requested.", t)); }, t => true); using (var db = new BlobDatabase(serializer)) { db.CreateTable <UnsupportedTypes>(); item = new UnsupportedTypes() { Id = Guid.NewGuid(), DateTimeOffset = DateTime.Now, DivideByZeroException = new DivideByZeroException("a message") }; db.Insert(item); var dbItem = db.Find <UnsupportedTypes>(item.Id); Assert.AreEqual(item.Id, dbItem.Id); Assert.AreEqual(item.DateTimeOffset, dbItem.DateTimeOffset); Assert.AreEqual(item.DivideByZeroException.Message, dbItem.DivideByZeroException.Message); } }
private static void CreateCommand(BlobDatabase database, string[] tokens) { var name = tokens[1]; var health = int.Parse(tokens[2]); var damage = int.Parse(tokens[3]); var behaviourType = tokens[4]; var attackType = tokens[5]; var createdBlob = new Blob(name, health, damage, behaviourType == "Aggressive" ? (IBehavior) new AggressiveBehavior() : new InflatedBehavior(), attackType == "PutridFart" ? (IAttack) new PutridFart() : new Blobplode()); database.Add(createdBlob); }
public void VerifyTableCreationSucceedsWithSupportedSerializer() { if (!this.Serializer.CanDeserialize(typeof(ComplexOrder))) { Assert.Ignore("Serialize does not support this data type"); } using (var db = new BlobDatabase(this.Serializer)) { db.CreateTable <ComplexOrder>(); var mapping = db.GetMapping <ComplexOrder>(); Assert.IsNotNull(mapping); Assert.AreEqual(4, mapping.Columns.Length); } }
public void DoesNotCallOnSupportedTypes() { var types = new List <Type>(); var serializer = new BlobSerializerDelegate(obj => null, (d, t) => null, t => { throw new InvalidOperationException(string.Format("Type {0} should not be requested.", t)); }); using (var db = new BlobDatabase(serializer)) { db.CreateTable <SupportedTypes>(); } Assert.AreEqual(0, types.Count, "Types requested from serializer"); }
public void CallsOnUnsupportedTypes() { var types = new List <Type>(); var serializer = new BlobSerializerDelegate(obj => null, (d, t) => null, t => { types.Add(t); return(true); }); using (var db = new BlobDatabase(serializer)) { db.CreateTable <UnsupportedTypes>(); } Assert.That(types, Has.Member(typeof(DivideByZeroException))); Assert.AreEqual(1, types.Count, "Too many types requested by serializer"); }
public void CallsOnUnsupportedTypes() { var types = new List <Type>(); var serializer = new BlobSerializerDelegate(obj => null, (d, t) => null, t => { types.Add(t); return(true); }); using (var db = new BlobDatabase(serializer)) { db.CreateTable <UnsupportedTypes>(); } Assert.Contains(typeof(DateTimeOffset), types); Assert.AreEqual(1, types.Count, "Too many types requested by serializer"); }
public void CanDeserializeIsRequested() { var types = new List <Type>(); var serializer = new BlobSerializerDelegate(obj => null, (d, t) => null, t => { types.Add(t); return(true); }); using (var db = new BlobDatabase(serializer)) { db.CreateTable <ComplexOrder>(); } Assert.That(types, Has.Member(typeof(List <ComplexHistory>))); Assert.That(types, Has.Member(typeof(List <ComplexLine>))); Assert.AreEqual(2, types.Count, "Too many types requested by serializer"); }
public void VerifyTableCreationFailsWithNoSerializer() { NotSupportedException ex = null; using (var db = new BlobDatabase(null)) { try { var count = db.CreateTable <ComplexOrder>(); Assert.IsTrue(count == 0); Assert.IsNull(db.GetMapping <ComplexOrder>()); return; } catch (NotSupportedException e) { ex = e; } } Assert.IsNotNull(ex); }
private static void AttackCommand(BlobDatabase database, string[] tokens) { var sourceBlob = database.First(a => a.Name == tokens[1]); var targetBlob = database.First(a => a.Name == tokens[2]); sourceBlob.Attack(targetBlob); if (sourceBlob.Health <= sourceBlob.InitialHealth / 2) { sourceBlob.BlobBehavior.Trigger(targetBlob); } if (targetBlob.Health <= targetBlob.InitialHealth/2) { targetBlob.BlobBehavior.Trigger(targetBlob); } if (targetBlob.Health <= 0) { targetBlob.IsAlive = false; } }
//[Test] public void TestListOfObjects() { if (!this.Serializer.CanDeserialize(typeof(ComplexOrder))) { Assert.Ignore("Serialize does not support this data type"); } using (var db = new BlobDatabase(this.Serializer)) { db.CreateTable <ComplexOrder>(); var order = new ComplexOrder(); var count = db.Insert(order); Assert.AreEqual(count, 1); var orderCopy = db.Find <ComplexOrder>(order.Id); Assert.AreEqual(order, orderCopy); for (var n = 0; n < 10;) { order.Lines.Add(new ComplexLine() { ProductId = 1, Quantity = ++n, Status = OrderLineStatus.Placed, UnitPrice = (n / 10m) }); db.Update(order); orderCopy = db.Find <ComplexOrder>(order.Id); Assert.AreEqual(order, orderCopy); order.History.Add(new ComplexHistory() { Time = DateTime.UtcNow, Comment = string.Format("New history {0}", n) }); db.Update(order); orderCopy = db.Find <ComplexOrder>(order.Id); Assert.AreEqual(order, orderCopy); } } }
public BlobEngine(BlobDatabase blobDatabase, IReader input, IWriter output) { BlobDatabase = blobDatabase; Input = input; Output = output; }
private static void StatusCommand(IWriter output, BlobDatabase database) { StringBuilder sb = new StringBuilder(); foreach (var blob in database) { sb.AppendLine(blob.ToString()); } output.Write(sb.ToString()); }