public void ShouldRecordAndPlayEvents()
{
var random = new Random();
var machineThreadFunctionFactory = new Func<BaseClockSource, ThreadStart>(cSource => new ThreadStart(() =>
{
for(var i = 0; i < 100; i++)
{
Thread.Sleep(10);
cSource.Advance(10);
}
}));
var machineFactory = new Func<BaseClockSource, Machine>(cSource =>
{
var sDomain = new SynchronizationDomain();
var result = new Machine();
result.SetClockSource(cSource);
result.SyncUnit = 10;
result.SyncDomain = sDomain;
var peripheral = new PeripheralMock(result, sDomain);
result.SystemBus.Register(peripheral, 0.To(1));
result.SetLocalName(peripheral, "mock");
return result;
});
var clockSource = clockSources[0];
var machine = machineFactory(clockSource);
var peripheralMock = (PeripheralMock)machine["sysbus.mock"];
machine.RecordTo(temporaryFile.Value);
var machineThread = new Thread(machineThreadFunctionFactory(clockSource));
machineThread.Start();
var eventNo = 0;
while(!machineThread.Join(0))
{
peripheralMock.Method(eventNo++);
peripheralMock.MethodTwoArgs(eventNo++, 0);
Thread.Sleep(random.Next(30));
}
machine.Dispose();
var recordedEvents = peripheralMock.Events;
clockSource = clockSources[1];
machine = machineFactory(clockSource);
peripheralMock = (PeripheralMock)machine["sysbus.mock"];
machine.PlayFrom(temporaryFile.Value);
machineThread = new Thread(machineThreadFunctionFactory(clockSource));
machineThread.Start();
machineThread.Join();
var playedEvents = peripheralMock.Events;
CollectionAssert.AreEqual(recordedEvents, playedEvents);
}
public DevicesConfig(string filename, Machine machine)
{
try
{
var devices = InitializeJSON(filename);
this.machine = machine;
//Every main node is one peripheral/device
foreach(var dev in devices)
{
InitializeDevice(dev);
}
while(deferred.Count > 0)
{
var lastCount = deferred.Count;
foreach(var deferredDevice in deferred.ToList())
{
if(InitializeDevice(deferredDevice.Key, deferredDevice.Value))
{
deferred.Remove(deferredDevice.Key);
}
}
if(lastCount == deferred.Count)
{
throw new ConstructionException("The provided configuration is not consistent. Some devices could not have been created due to wrong references.");
}
}
//Initialize connections
while(deviceList.Any(x => !x.IsRegistered))
{
var anyChange = false;
//setup connections
foreach(var periConn in deviceList.Where(x=> !x.IsRegistered && x.HasConnections))
{
var parents = new Dictionary<string, IPeripheral>();
foreach(var conn in periConn.Connections.Select(x=>x.Key))
{
var fromList = deviceList.SingleOrDefault(x => x.Name == conn);
if(fromList != null)
{
parents.Add(conn, fromList.Peripheral);
}
else
{
IPeripheral candidate;
if(!machine.TryGetByName(conn, out candidate))
{
FailDevice(periConn.Name, "connection to " + conn, null);
}
parents.Add(conn, candidate);
}
}
var canBeRegistered = parents.All(x => machine.IsRegistered(x.Value));
if(canBeRegistered)
{
RegisterInParents(periConn, parents);
periConn.IsRegistered = true;
anyChange = true;
}
}
if(!anyChange)
{
var invalidDevices = deviceList.Where(x => !x.IsRegistered).Select(x => x.Name).Aggregate((x, y) => x + ", " + y);
throw new RegistrationException("The " +
"provided configuration is not consistent. The following devices could not have been registered: "
+ invalidDevices
);
}
}
foreach(var device in deviceList.Where(x=>x.Irqs.Any()))
{
InitializeGPIOs(device);
}
foreach(var device in deviceList.Where(x=>x.IrqsFrom.Any()))
{
InitializeGPIOsFrom(device);
}
}
catch(RuntimeBinderException e)
{
throw new RecoverableException("The config file could not be analyzed. You should reset your current emulation.", e);
}
foreach(var group in groups)
{
machine.PeripheralsGroups.GetOrCreate(group.Key, group.Value.Select(x => x.Peripheral));
}
foreach(var device in deviceList)
{
machine.SetLocalName(device.Peripheral, device.Name);
}
}
public void ShouldRememberCpuNames()
{
var names = new [] { "Xavier", "Alice", "Bob" };
var machine = new Machine();
foreach(var name in names)
{
var cpu = new MockCPU(machine) { Placeholder = name };
machine.SystemBus.Register(cpu, new CPURegistrationPoint());
machine.SetLocalName(cpu, name);
}
machine = Serializer.DeepClone(machine);
var cpus = machine.SystemBus.GetCPUs();
CollectionAssert.AreEquivalent(names, cpus.Select(x => machine.GetLocalName(x)));
foreach(var cpu in cpus.Cast<MockCPU>())
{
Assert.AreEqual(cpu.Placeholder, machine.GetLocalName(cpu));
}
}