public void CreateSimulation()
{
Simulation sim = new Simulation();
Assert.AreEqual(0, sim.Run());
Assert.AreEqual(0L, sim.Now);
Assert.AreEqual(0L, sim.StopTime);
}
public void ScheduleStop()
{
long stopIn = 1000L;
Simulation sim = new Simulation();
StopSimulation.Stop(sim, stopIn);
Assert.AreEqual(0, sim.Run());
Assert.AreEqual(stopIn, sim.Now);
Assert.AreEqual(stopIn, sim.StopTime);
}
public void TransferAnonymous()
{
IResource resource = Resource.Create(2);
Simulation sim = new Simulation();
Task task = new Process(sim, TransferTask, resource);
task.Activate(null);
sim.Run();
Assert.AreEqual(2, resource.Free);
}
public void TransferTracked()
{
IResource resource = Resource.Create(Names);
Simulation sim = new Simulation();
Task task = new Process(sim, TransferTask, resource);
task.Activate(null);
sim.Run();
Assert.AreEqual(Names.Length, resource.Free);
}
public void AcquireAllDisallowed()
{
Resource resource = Resource.Create(10);
resource.AllowOwnMany = false;
Simulation sim = new Simulation();
Process process = new Process(sim, AcquireAll, resource);
sim.Run(process);
}
public void BlockedWhenNotSignalled()
{
Condition target = new Condition();
Simulation sim = new Simulation();
Task nop = new NoOperation(sim);
Task blk = target.Block(nop);
sim.Run(blk);
Assert.AreEqual(1, target.BlockCount);
}
public void InterruptedAcquire()
{
IResource resource = Resource.Create(3);
Simulation sim = new Simulation();
Process process = new Process(sim, AcquireOneInterrupted, resource);
process.Activate(null);
Assert.AreEqual(resource.Count, resource.Free);
sim.Run();
Assert.AreEqual(resource.Count, resource.Free);
}
public void ScheduleAfterCompleted()
{
Simulation sim = new Simulation();
Delay delay = new Delay(sim, 100L);
sim.Run(delay);
Assert.AreEqual(SimulationState.Completed, sim.State);
delay = new Delay(sim, 200L);
// Simulation complete, should throw exception.
delay.Activate(null);
}
public void AcquireAllResources()
{
Resource resource = Resource.Create(10);
resource.AllowOwnMany = true;
Simulation sim = new Simulation();
Process process = new Process(sim, AcquireAll, resource);
Assert.AreEqual(resource.Count, resource.Free);
sim.Run(process);
Assert.AreEqual(0, resource.Free);
Assert.AreEqual(resource.Count, resource.InUse);
}
public void CountToTen()
{
CounterProcess cp = new CounterProcess(_sim, 10);
_sim.Run(new Task [] { cp });
Assert.AreEqual(10, cp.CurrentIteration);
Assert.AreEqual(100L, _sim.Now);
}
public void ResumeOnSignal()
{
Condition target = new Condition();
Simulation sim = new Simulation();
Task unblock = new Process(sim, SignalCondition, target);
Task nop = new NoOperation(sim);
Task block = target.Block(nop);
nop.WaitOnTask(block);
sim.Run(new Task[] { block, unblock });
Assert.IsFalse(target.Signalled);
Assert.AreEqual(0, target.BlockCount);
Assert.AreEqual(10L, sim.StopTime);
}
public void ScheduleMultipleStops()
{
Simulation sim = new Simulation();
for (int i = 0; i < 10; i++)
{
long stopIn = 1000L * i + 1000L;
StopSimulation.Stop(sim, stopIn);
}
Assert.AreEqual(9, sim.Run());
Assert.AreEqual(1000L, sim.Now);
Assert.AreEqual(1000L, sim.StopTime);
}
public void TransferUsingInterrupt()
{
IResource resource = Resource.Create(1);
Simulation sim = new Simulation();
Task task1 = new Process(sim, TransferAndInterrupt, resource);
task1.Name = "Task #1";
Task task2 = new Process(sim, TransferAndInterrupt, resource);
task2.Name = "Task #2";
task1.Activate(null, 0L, task2);
task2.Activate(null, 0L, task1);
sim.Run();
Assert.AreEqual(1, resource.Free);
}
public void NotBlockedWhenSignalled()
{
Condition target = new Condition();
target.AutoReset = false;
target.Signal();
Simulation sim = new Simulation();
Task nop = new NoOperation(sim);
Task blk = target.Block(nop);
nop.WaitOnTask(blk);
Assert.IsTrue(target.Signalled);
sim.Run(blk);
Assert.AreEqual(0, target.BlockCount);
}
public void SetInServiceTracked()
{
IResource resource = Resource.Create(Names);
Simulation sim = new Simulation();
resource.OutOfService = resource.Count;
Task[] tasks = new Task[resource.Count + 1];
for (int i = 0; i < resource.Count; i++)
{
Task nop = new NoOperation(sim);
tasks[i] = resource.Acquire(nop);
nop.WaitOnTask(tasks[i]);
}
tasks[tasks.Length - 1] = new Process(sim, SetInService, resource);
sim.Run(tasks);
Assert.AreEqual(Names.Length, resource.InUse);
}
public void SetOutOfServiceAnonymous()
{
IResource resource = Resource.Create(7);
Simulation sim = new Simulation();
resource.OutOfService = 2;
Task[] tasks = new Task[resource.Count];
for (int i = 0; i < resource.Count; i++)
{
Task nop = new NoOperation(sim);
tasks[i] = resource.Acquire(nop);
nop.WaitOnTask(tasks[i]);
}
sim.Run(tasks);
Assert.AreEqual(resource.Count - resource.OutOfService,
resource.InUse);
}
public void OrderedByPriority()
{
IQueue <int> fifo = new FifoQueue <int>();
Simulation sim = new Simulation();
for (int i = 0; i < 100; i++)
{
Task t = new OrderingTask(sim, i);
t.Activate(null, 123L, fifo, 100 - i - 1);
}
int tasksNotRun = sim.Run();
Assert.AreEqual(0, tasksNotRun);
Assert.AreEqual(100, fifo.Count);
for (int v = 0; fifo.Count > 0; v++)
{
Assert.AreEqual(v, fifo.Dequeue());
}
}
