public void EnumeratesHardwareControllers()
{
Controller controller = new Controller();
IDAQController daq = new SimpleDAQController();
controller.DAQController = daq;
Assert.AreEqual(new IHardwareController[] { daq } as IEnumerable <IHardwareController>, controller.HardwareControllers);
}
public void ShouldSetStreamBackgroundOnStop()
{
var c = new SimpleDAQController(new IDAQStream[0])
{
BackgroundSet = false
};
c.Start(false);
Assert.That(c.BackgroundSet, Is.True);
}
public void ShouldNotSetBackgroundWhenStreamDoesNotUseThisController()
{
var c = new SimpleDAQController(new IDAQStream[0])
{
BackgroundSet = false
};
var s = new DAQOutputStream("test", null);
Assert.That(() => c.ApplyStreamBackground(s), Throws.Exception.TypeOf <DAQException>());
}
public void ShouldThrowForMultipleStreamsWhenGettingStream()
{
var c = new SimpleDAQController();
string name = "stream-name";
(c as IMutableDAQController).AddStream(new DAQOutputStream(name));
(c as IMutableDAQController).AddStream(new DAQOutputStream(name));
Assert.Throws <InvalidOperationException>(() => c.GetStream(name));
}
public void GetStreamReturnsNullForUnknownName()
{
var c = new SimpleDAQController();
const string name = "stream-name";
const string distractor = "distractor-name";
var outStream = new DAQOutputStream(name);
(c as IMutableDAQController).AddStream(outStream);
Assert.That(c.GetStream <IDAQOutputStream>(distractor), Is.Null);
Assert.That(c.GetStream <IDAQInputStream>(distractor), Is.Null);
Assert.That(c.GetStream <IDAQInputStream>(name), Is.Null);
}
public void GetStreamReturnsStreamWithName()
{
var c = new SimpleDAQController();
const string name = "stream-name";
var outStream = new DAQOutputStream(name);
(c as IMutableDAQController).AddStream(outStream);
var inputStream = new DAQInputStream(name);
(c as IMutableDAQController).AddStream(inputStream);
Assert.That(c.GetStream <IDAQOutputStream>(name), Is.EqualTo(outStream));
Assert.That(c.GetStream <IDAQInputStream>(name), Is.EqualTo(inputStream));
}
public void ShouldSetStreamBackgroundWhenStopped()
{
var c = new SimpleDAQController(new IDAQStream[0])
{
BackgroundSet = false, AsyncBackground = null
};
var s = new DAQOutputStream("test", c);
c.AddStream(s);
c.SetRunning(false);
var device = new DynamicMock(typeof(IExternalDevice));
var background = new Measurement(0, "V");
device.ExpectAndReturn("get_OutputBackground", background);
s.MeasurementConversionTarget = "V";
s.Device = device.MockInstance as IExternalDevice;
s.ApplyBackground();
Assert.That(c.AsyncBackground, Is.EqualTo(background));
}
public void GetsStreamsByName()
{
string name1 = "IN1";
string name2 = "IN2";
string name3 = "OUT1";
IDAQStream in1 = new DAQInputStream(name1);
IDAQStream in2 = new DAQInputStream(name2);
IDAQStream in3 = new DAQInputStream(name1);
IDAQStream out1 = new DAQOutputStream(name3);
var c = new SimpleDAQController();
(c as IMutableDAQController).AddStream(in1);
(c as IMutableDAQController).AddStream(in2);
(c as IMutableDAQController).AddStream(in3);
(c as IMutableDAQController).AddStream(out1);
Assert.AreEqual(2, c.GetStreams(name1).Count());
Assert.AreEqual(1, c.GetStreams(name2).Count());
Assert.AreEqual(1, c.GetStreams(name3).Count());
Assert.AreEqual(in2, c.GetStreams(name2).First());
Assert.AreEqual(out1, c.GetStreams(name3).First());
}
public void PullsOutputData()
{
const int srate = 1000;
var daq = new SimpleDAQController();
var c = new NonValidatingController { DAQController = daq };
var dev = new UnitConvertingExternalDevice(UNUSED_DEVICE_NAME, UNUSED_DEVICE_MANUFACTURER, c,
UNUSED_BACKGROUND)
{
OutputSampleRate = new Measurement(srate, "Hz")
};
dev.BindStream(new DAQOutputStream("out"));
IList<IMeasurement> data = (IList<IMeasurement>) Enumerable.Range(0, srate * 2).Select(i => new Measurement(i, "V") as IMeasurement).ToList();
var sampleRate = new Measurement(srate, "Hz");
IOutputData data1 = new OutputData(data, sampleRate, false);
var e = new Epoch("");
e.Stimuli[dev] = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) new Dictionary<string, object>(),
data1);
TimeSpan d1 = TimeSpan.FromSeconds(0.75);
IOutputData pull1 = null;
IOutputData pull2 = null;
IOutputData pull3 = null;
bool pulled = false;
daq.Started += (evt, args) =>
{
pull1 = c.PullOutputData(dev, d1);
pull2 = c.PullOutputData(dev, d1);
pull3 = c.PullOutputData(dev, d1);
pulled = true;
c.RequestStop();
};
c.EnqueueEpoch(e);
c.StartAsync(null);
while (!pulled)
{
Thread.Sleep(1);
}
var samples = (int)d1.Samples(new Measurement(srate, "Hz"));
Assert.AreEqual(data.Take(samples).ToList(),
pull1.Data);
Assert.AreEqual(data.Skip(samples).Take(samples).ToList(),
pull2.Data);
Assert.AreEqual(data.Skip(2 * samples)
.Take(samples)
.Concat(Enumerable.Range(0, srate - samples).Select(i => dev.Background))
.ToList(),
pull3.Data);
}
public void EnumeratesHardwareControllers()
{
Controller controller = new Controller();
IDAQController daq = new SimpleDAQController();
controller.DAQController = daq;
Assert.AreEqual(new IHardwareController[] { daq } as IEnumerable<IHardwareController>, controller.HardwareControllers);
}
public void RunEpochShouldRespectEpochWaitForTrigger()
{
var c = new Controller();
var daq = new SimpleDAQController();
daq.Clock = new SystemClock();
c.DAQController = daq;
var e = new Epoch(UNUSED_PROTOCOL) { ShouldWaitForTrigger = true };
new TaskFactory().StartNew(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(1));
c.RequestStop();
},
TaskCreationOptions.LongRunning);
c.RunEpoch(e, new FakeEpochPersistor());
Assert.IsTrue(daq.WaitedForTrigger);
}
public void PushesDataToEpoch()
{
const string UNUSED_NAME = "UNUSED";
var daq = new SimpleDAQController();
var c = new NonValidatingController { DAQController = daq };
var dev = new UnitConvertingExternalDevice(UNUSED_NAME, UNUSED_DEVICE_MANUFACTURER, c, UNUSED_BACKGROUND);
var outStream = new DAQOutputStream("out");
var inStream = new DAQInputStream("in");
dev.BindStream(outStream).BindStream(inStream);
var srate = new Measurement(100, "Hz");
var samples = Enumerable.Range(0, 100).Select(i => new Measurement(1, "V")).ToList();
var e = new Epoch("PushesDataToEpoch");
e.Responses[dev] = new Response();
e.Stimuli[dev] = new RenderedStimulus((string) "ID1", (IDictionary<string, object>) new Dictionary<string, object>(), (IOutputData) new OutputData(samples, srate, false));
var data = new InputData(samples, srate, DateTimeOffset.Now).DataWithStreamConfiguration(inStream, new Dictionary<string, object>());
bool pushed = false;
daq.Started += (evt, args) =>
{
c.PushInputData(dev, data);
pushed = true;
c.RequestStop();
};
c.EnqueueEpoch(e);
c.StartAsync(null);
while (!pushed)
{
Thread.Sleep(1);
}
Assert.That(e.Responses[dev].Data, Is.EqualTo(data.Data));
Assert.That(e.Responses[dev].InputTime, Is.EqualTo(data.InputTime));
Assert.That(e.Responses[dev].DataConfigurationSpans.First().Nodes.First(),
Is.EqualTo(data.NodeConfigurationWithName(inStream.Name)));
}
public void ShouldTruncateResponseAtEpochBoundary()
{
Converters.Register("V", "V",
(IMeasurement m) => m);
var daq = new SimpleDAQController();
var c = new NonValidatingController { DAQController = daq };
var dev = new UnitConvertingExternalDevice("dev", UNUSED_DEVICE_MANUFACTURER, c, UNUSED_BACKGROUND);
var outStream = new DAQOutputStream("out");
var inStream = new DAQInputStream("in");
dev.BindStream(outStream).BindStream(inStream);
var sampleRate = new Measurement(1, "Hz");
var samples = new List<IMeasurement> { new Measurement(1, "V"), new Measurement(2, "V"), new Measurement(3, "V") };
var data = new OutputData(samples,
sampleRate, true);
var e = new Epoch(UNUSED_PROTOCOL);
e.Stimuli[dev] = new RenderedStimulus((string) "ID1",
(IDictionary<string, object>) new Dictionary<string, object>(),
(IOutputData) data);
e.Responses[dev] = new Response();
bool pushed = false;
daq.Started += (evt, args) =>
{
c.PullOutputData(dev, data.Duration);
c.PushInputData(dev, new InputData(samples.Concat(samples).ToList(),
sampleRate,
DateTimeOffset.Now)
.DataWithStreamConfiguration(streamFake, new Dictionary<string, object>())
.DataWithExternalDeviceConfiguration(devFake, new Dictionary<string, object>()));
pushed = true;
c.RequestStop();
};
c.EnqueueEpoch(e);
c.StartAsync(null);
while (!pushed)
{
Thread.Sleep(1);
}
Assert.That(((TimeSpan)e.Responses[dev].Duration), Is.EqualTo((TimeSpan)e.Duration));
}
public void ShouldSupplyEpochBackgroundForExternalDevicesWithoutStimuli()
{
Converters.Register("V", "V",
(IMeasurement m) => m);
int baseSamples = 1000;
var daq = new SimpleDAQController();
var c = new NonValidatingController { DAQController = daq };
var dev1 = new UnitConvertingExternalDevice("dev1", "co", c, new Measurement(0, "V"))
{
OutputSampleRate = new Measurement(baseSamples, "Hz")
};
var dev2 = new UnitConvertingExternalDevice("dev2", "co", c, new Measurement(0, "V"))
{
OutputSampleRate = new Measurement(baseSamples, "Hz")
};
dev1.BindStream(new DAQOutputStream("out1"));
dev2.BindStream(new DAQOutputStream("out2"));
IList<IMeasurement> data = (IList<IMeasurement>)Enumerable.Range(0, baseSamples)
.Select(i => new Measurement(i, "V") as IMeasurement)
.ToList();
Measurement sampleRate = new Measurement(baseSamples, "Hz");
var config = new Dictionary<string, object>();
IOutputData data1 = new OutputData(data, sampleRate, true);
var e = new Epoch("");
e.Stimuli[dev1] = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) config, data1);
var backgroundMeasurement = new Measurement(3.2m, "V");
e.Backgrounds[dev2] = new Background(backgroundMeasurement, sampleRate);
IOutputData out1 = null;
IOutputData out2 = null;
bool pulled = false;
daq.Started += (evt, args) =>
{
out1 = c.PullOutputData(dev1, e.Duration);
out2 = c.PullOutputData(dev2, e.Duration);
pulled = true;
c.RequestStop();
};
c.EnqueueEpoch(e);
c.StartAsync(null);
while (!pulled)
{
Thread.Sleep(1);
}
Assert.NotNull(out1);
Assert.NotNull(out2);
Assert.AreEqual((TimeSpan)e.Duration, out2.Duration);
Assert.AreEqual(backgroundMeasurement, out2.Data.First());
}
public void PullOutputDataShouldReturnBackgroundStreamWithNoRemainingEpochs()
{
var daq = new SimpleDAQController();
Controller c = new NonValidatingController() { DAQController = daq };
IExternalDevice dev = new UnitConvertingExternalDevice(UNUSED_DEVICE_NAME, UNUSED_DEVICE_MANUFACTURER, c,
UNUSED_BACKGROUND)
{
OutputSampleRate = new Measurement(1000, "Hz")
};
dev.BindStream(new DAQOutputStream("out"));
var srate = dev.OutputSampleRate;
TimeSpan dur = TimeSpan.FromSeconds(0.5);
var samples = (int)dur.Samples(srate);
var e = new Epoch("");
e.Stimuli[dev] = new RenderedStimulus("RenderedStimulus", new Dictionary<string, object>(), new OutputData(Enumerable.Repeat(new Measurement(0, "V"), samples), srate));
IOutputData pull1 = null;
IOutputData pull2 = null;
bool pulled = false;
daq.Started += (evt, args) =>
{
// Pull out epoch data
c.PullOutputData(dev, dur);
pull1 = c.PullOutputData(dev, dur);
pull2 = c.PullOutputData(dev, dur);
pulled = true;
c.RequestStop();
};
c.EnqueueEpoch(e);
c.StartAsync(null);
while (!pulled)
{
Thread.Sleep(1);
}
var expected = Enumerable.Repeat(dev.Background, samples).ToList();
Assert.AreEqual(expected, pull1.Data);
Assert.AreEqual(expected, pull2.Data);
}
public void ShouldSetStreamBackgroundWhenStopped()
{
var c = new SimpleDAQController(new IDAQStream[0]) { BackgroundSet = false, AsyncBackground = null};
var s = new DAQOutputStream("test", c);
c.AddStream(s);
c.SetRunning(false);
var device = Substitute.For<IExternalDevice>();
var background = new Measurement(0, "V");
device.OutputBackground.Returns(background);
s.MeasurementConversionTarget = "V";
s.Devices.Add(device);
s.ApplyBackground();
var temp = device.Received().OutputBackground;
Assert.That(c.AsyncBackground, Is.EqualTo(background));
}
public void ShouldNotSetBackgroundWhenStreamDoesNotUseThisController()
{
var c = new SimpleDAQController(new IDAQStream[0]) { BackgroundSet = false };
var s = new DAQOutputStream("test", null);
Assert.That(()=> c.ApplyStreamBackground(s), Throws.Exception.TypeOf<DAQException>());
}
public void GetStreamReturnsNullForUnknownName()
{
var c = new SimpleDAQController();
const string name = "stream-name";
const string distractor = "distractor-name";
var outStream = new DAQOutputStream(name);
(c as IMutableDAQController).AddStream(outStream);
Assert.That(c.GetStream<IDAQOutputStream>(distractor), Is.Null);
Assert.That(c.GetStream<IDAQInputStream>(distractor), Is.Null);
Assert.That(c.GetStream<IDAQInputStream>(name), Is.Null);
}
public void CreatePipeline()
{
// Based on the "Minimal Rig.pdf" in the docs folder
Converters.Clear();
// We need an IClock
IClock clock = new FakeClock();
// We need a controller ...
Controller con = new Controller();
Converters.Register("units", "units",
// just an identity conversion for now, to pass Validate()
(IMeasurement m) => m);
Converters.Register("V", "units",
// just an identity conversion for now, to pass Validate()
(IMeasurement m) => m);
con.Clock = clock;
// Three ExternalDevices
CoalescingDevice amp = new CoalescingDevice("Amp", UNUSED_DEVICE_MANUFACTURER, con, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
var LED = new UnitConvertingExternalDevice("LED", UNUSED_DEVICE_MANUFACTURER, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
var temp = new UnitConvertingExternalDevice("Temp", UNUSED_DEVICE_MANUFACTURER, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
amp.Clock = clock;
LED.Clock = clock;
temp.Clock = clock;
con.AddDevice(LED).AddDevice(temp);
// There should be no difference whether we use the
// ExternalDevice constructor to wire up the Controller
// to the ExternalDevice, or the explicit Add() call
Assert.IsNotNull(amp.Controller);
Assert.IsNotNull(LED.Controller);
Assert.IsNotNull(temp.Controller);
Assert.IsTrue(amp.Controller == con);
Assert.IsTrue(LED.Controller == con);
Assert.IsTrue(temp.Controller == con);
// Five DAQStreams
DAQInputStream in0 = new DAQInputStream("In-0"); in0.Clock = clock;
DAQInputStream in1 = new DAQInputStream("In-1"); in1.Clock = clock;
DAQInputStream in2 = new DAQInputStream("In-2"); in2.Clock = clock;
DAQOutputStream out0 = new DAQOutputStream("Out-0"); out0.Clock = clock;
DAQOutputStream out1 = new DAQOutputStream("Out-1"); out1.Clock = clock;
in0.MeasurementConversionTarget = "units";
in1.MeasurementConversionTarget = "units";
in2.MeasurementConversionTarget = "units";
out0.MeasurementConversionTarget = "units";
out1.MeasurementConversionTarget = "units";
//amp.Coalesce = CoalescingDevice.OneItemCoalesce;
amp.Configuration["CoalesceProc"] = "Symphony.Core.CoalescingDevice.OneItemCoalesce";
LED.BindStream(out0);
amp.BindStream(out1).BindStream(in0).BindStream(in1);
amp.Connect(in0, in1);
temp.BindStream(in2);
Assert.IsTrue(LED.Streams.Count == 1);
Assert.IsTrue(amp.Streams.Count == 3);
Assert.IsTrue(temp.Streams.Count == 1);
Assert.IsTrue(in0.Devices.Contains(amp));
Assert.IsTrue(in1.Devices.Contains(amp));
Assert.IsTrue(in2.Devices.Contains(temp));
Assert.IsTrue(out0.Device == LED);
Assert.IsTrue(out1.Device == amp);
// One DAQController
IDAQController dc =
new SimpleDAQController(new IDAQStream[] { in0, in1, in2, out0, out1 });
con.DAQController = dc;
// DAQController-to-streams
Assert.IsTrue(dc.InputStreams.Contains(in0));
Assert.IsTrue(dc.InputStreams.Contains(in1));
Assert.IsTrue(dc.InputStreams.Contains(in2));
Assert.IsTrue(dc.OutputStreams.Contains(out0));
Assert.IsTrue(dc.OutputStreams.Contains(out0));
// Validate and report the validation results
Maybe <string> conVal = con.Validate();
Assert.IsTrue(conVal, conVal.Item2);
Assert.IsTrue(amp.Coalesce == CoalescingDevice.OneItemCoalesce);
}
public void GetStreamReturnsStreamWithName()
{
var c = new SimpleDAQController();
const string name = "stream-name";
var outStream = new DAQOutputStream(name);
(c as IMutableDAQController).AddStream(outStream);
var inputStream = new DAQInputStream(name);
(c as IMutableDAQController).AddStream(inputStream);
Assert.That(c.GetStream<IDAQOutputStream>(name), Is.EqualTo(outStream));
Assert.That(c.GetStream<IDAQInputStream>(name), Is.EqualTo(inputStream));
}
public void GetsStreamsByName()
{
string name1 = "IN1";
string name2 = "IN2";
string name3 = "OUT1";
IDAQStream in1 = new DAQInputStream(name1);
IDAQStream in2 = new DAQInputStream(name2);
IDAQStream in3 = new DAQInputStream(name1);
IDAQStream out1 = new DAQOutputStream(name3);
var c = new SimpleDAQController();
(c as IMutableDAQController).AddStream(in1);
(c as IMutableDAQController).AddStream(in2);
(c as IMutableDAQController).AddStream(in3);
(c as IMutableDAQController).AddStream(out1);
Assert.AreEqual(2, c.GetStreams(name1).Count());
Assert.AreEqual(1, c.GetStreams(name2).Count());
Assert.AreEqual(1, c.GetStreams(name3).Count());
Assert.AreEqual(in2, c.GetStreams(name2).First());
Assert.AreEqual(out1, c.GetStreams(name3).First());
}
public void ShouldSetStreamBackgroundOnStop()
{
var c = new SimpleDAQController(new IDAQStream[0]) {BackgroundSet = false};
c.Start(false);
Assert.That(c.BackgroundSet, Is.True);
}
public void CreatePipeline()
{
// Based on the "Minimal Rig.pdf" in the docs folder
Converters.Clear();
// We need an IClock
IClock clock = new FakeClock();
// We need a controller ...
Controller con = new Controller();
Converters.Register("units", "units",
// just an identity conversion for now, to pass Validate()
(IMeasurement m) => m);
Converters.Register("V", "units",
// just an identity conversion for now, to pass Validate()
(IMeasurement m) => m);
con.Clock = clock;
// Three ExternalDevices
CoalescingDevice amp = new CoalescingDevice("Amp", UNUSED_DEVICE_MANUFACTURER, con, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
var LED = new UnitConvertingExternalDevice("LED", UNUSED_DEVICE_MANUFACTURER, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
var temp = new UnitConvertingExternalDevice("Temp", UNUSED_DEVICE_MANUFACTURER, UNUSED_BACKGROUND)
{
MeasurementConversionTarget = "units"
};
amp.Clock = clock;
LED.Clock = clock;
temp.Clock = clock;
con.AddDevice(LED).AddDevice(temp);
// There should be no difference whether we use the
// ExternalDevice constructor to wire up the Controller
// to the ExternalDevice, or the explicit Add() call
Assert.IsNotNull(amp.Controller);
Assert.IsNotNull(LED.Controller);
Assert.IsNotNull(temp.Controller);
Assert.IsTrue(amp.Controller == con);
Assert.IsTrue(LED.Controller == con);
Assert.IsTrue(temp.Controller == con);
// Five DAQStreams
DAQInputStream in0 = new DAQInputStream("In-0"); in0.Clock = clock;
DAQInputStream in1 = new DAQInputStream("In-1"); in1.Clock = clock;
DAQInputStream in2 = new DAQInputStream("In-2"); in2.Clock = clock;
DAQOutputStream out0 = new DAQOutputStream("Out-0"); out0.Clock = clock;
DAQOutputStream out1 = new DAQOutputStream("Out-1"); out1.Clock = clock;
in0.MeasurementConversionTarget = "units";
in1.MeasurementConversionTarget = "units";
in2.MeasurementConversionTarget = "units";
out0.MeasurementConversionTarget = "units";
out1.MeasurementConversionTarget = "units";
//amp.Coalesce = CoalescingDevice.OneItemCoalesce;
amp.Configuration["CoalesceProc"] = "Symphony.Core.CoalescingDevice.OneItemCoalesce";
LED.BindStream(out0);
amp.BindStream(out1).BindStream(in0).BindStream(in1);
amp.Connect(in0, in1);
temp.BindStream(in2);
Assert.IsTrue(LED.Streams.Count == 1);
Assert.IsTrue(amp.Streams.Count == 3);
Assert.IsTrue(temp.Streams.Count == 1);
Assert.IsTrue(in0.Devices.Contains(amp));
Assert.IsTrue(in1.Devices.Contains(amp));
Assert.IsTrue(in2.Devices.Contains(temp));
Assert.IsTrue(out0.Device == LED);
Assert.IsTrue(out1.Device == amp);
// One DAQController
IDAQController dc =
new SimpleDAQController(new IDAQStream[] { in0, in1, in2, out0, out1 });
con.DAQController = dc;
// DAQController-to-streams
Assert.IsTrue(dc.InputStreams.Contains(in0));
Assert.IsTrue(dc.InputStreams.Contains(in1));
Assert.IsTrue(dc.InputStreams.Contains(in2));
Assert.IsTrue(dc.OutputStreams.Contains(out0));
Assert.IsTrue(dc.OutputStreams.Contains(out0));
// Validate and report the validation results
Maybe<string> conVal = con.Validate();
Assert.IsTrue(conVal, conVal.Item2);
Assert.IsTrue(amp.Coalesce == CoalescingDevice.OneItemCoalesce);
}
public void ShouldThrowForMultipleStreamsWhenGettingTypedStream()
{
var c = new SimpleDAQController();
string name = "stream-name";
(c as IMutableDAQController).AddStream(new DAQOutputStream(name));
(c as IMutableDAQController).AddStream(new DAQOutputStream(name));
Assert.Throws<InvalidOperationException>(() => c.GetStream<IDAQOutputStream>(name));
}
public void ShouldSetStreamBackgroundWhenStopped()
{
var c = new SimpleDAQController(new IDAQStream[0]) { BackgroundSet = false, AsyncBackground = null};
var s = new DAQOutputStream("test", c);
c.AddStream(s);
c.SetRunning(false);
var device = new DynamicMock(typeof (IExternalDevice));
var background = new Measurement(0, "V");
device.ExpectAndReturn("get_OutputBackground", background);
s.MeasurementConversionTarget = "V";
s.Device = device.MockInstance as IExternalDevice;
s.ApplyBackground();
Assert.That(c.AsyncBackground, Is.EqualTo(background));
}
