C# Machine.SetLocalName方法代码示例

        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));
			}		
		}