encompass-cs/test/WorldBuilderTest.cs

214 lines
6.2 KiB
C#
Raw Normal View History

2019-06-17 00:56:36 +00:00
using NUnit.Framework;
using Encompass;
using System.Collections.Generic;
using Encompass.Exceptions;
2019-06-17 00:56:36 +00:00
namespace Tests
{
public class WorldBuilderTest
{
public class EngineCycleSimple
{
struct AMessage : IMessage { }
struct BMessage : IMessage { }
[Reads(typeof(AMessage))]
[Emits(typeof(BMessage))]
class AEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
BMessage message;
this.EmitMessage(message);
}
}
[Reads(typeof(BMessage))]
[Emits(typeof(AMessage))]
class BEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
AMessage message;
this.EmitMessage(message);
}
}
[Test]
public void EngineCycle()
{
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new AEngine());
worldBuilder.AddEngine(new BEngine());
2019-06-17 00:56:36 +00:00
Assert.Throws<EngineCycleException>(() => worldBuilder.Build());
}
}
public class EngineCycleComplex
{
struct AMessage : IMessage { }
struct BMessage : IMessage { }
struct CMessage : IMessage { }
struct DMessage : IMessage { }
[Reads(typeof(AMessage))]
[Emits(typeof(BMessage))]
class AEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
BMessage message;
this.EmitMessage(message);
}
}
[Reads(typeof(BMessage))]
[Emits(typeof(CMessage))]
class BEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
CMessage message;
this.EmitMessage(message);
}
}
[Reads(typeof(CMessage))]
[Emits(typeof(DMessage))]
class CEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
DMessage message;
this.EmitMessage(message);
}
}
[Reads(typeof(DMessage))]
[Emits(typeof(AMessage))]
class DEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
AMessage message;
this.EmitMessage(message);
}
}
[Test]
public void EngineCycle()
{
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new AEngine());
worldBuilder.AddEngine(new BEngine());
worldBuilder.AddEngine(new CEngine());
worldBuilder.AddEngine(new DEngine());
2019-06-17 00:56:36 +00:00
Assert.Throws<EngineCycleException>(() => worldBuilder.Build());
}
}
public class MutationConflict
{
struct AComponent : IComponent { }
[Mutates(typeof(AComponent))]
class AEngine : Engine
{
public override void Update(double dt) { }
2019-06-17 00:56:36 +00:00
}
[Mutates(typeof(AComponent))]
class BEngine : Engine
{
public override void Update(double dt) { }
2019-06-17 00:56:36 +00:00
}
[Test]
public void MutationConflictException()
{
var worldBuilder = new WorldBuilder();
worldBuilder.AddEngine(new AEngine());
worldBuilder.AddEngine(new BEngine());
2019-06-17 00:56:36 +00:00
Assert.Throws<EngineMutationConflictException>(() => worldBuilder.Build());
}
}
public class LegalEngines
{
static List<Engine> order = new List<Engine>();
struct AComponent : IComponent { }
struct BComponent : IComponent { }
struct AMessage : IMessage { }
struct BMessage : IMessage { }
struct CMessage : IMessage { }
struct DMessage : IMessage { }
[Mutates(typeof(AComponent))]
[Emits(typeof(AMessage))]
class AEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
order.Add(this);
}
}
[Mutates(typeof(BComponent))]
[Emits(typeof(BMessage))]
class BEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
order.Add(this);
}
}
[Reads(typeof(AMessage), typeof(BMessage))]
[Emits(typeof(DMessage))]
class CEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
order.Add(this);
}
}
[Reads(typeof(DMessage))]
class DEngine : Engine
{
public override void Update(double dt)
2019-06-17 00:56:36 +00:00
{
order.Add(this);
}
}
[Test]
public void EngineOrder()
{
var worldBuilder = new WorldBuilder();
var engineA = worldBuilder.AddEngine(new AEngine());
var engineB = worldBuilder.AddEngine(new BEngine());
var engineC = worldBuilder.AddEngine(new CEngine());
var engineD = worldBuilder.AddEngine(new DEngine());
2019-06-17 00:56:36 +00:00
Assert.DoesNotThrow(() => worldBuilder.Build());
var world = worldBuilder.Build();
world.Update(0.01f);
Assert.That(order.IndexOf(engineA), Is.LessThan(order.IndexOf(engineC)));
Assert.That(order.IndexOf(engineB), Is.LessThan(order.IndexOf(engineC)));
Assert.That(order.IndexOf(engineC), Is.LessThan(order.IndexOf(engineD)));
}
}
}
}