public void DelegatesBlocks()
{
var parameters = new Dictionary <string, object>();
parameters["sampleRate"] = new Measurement(1000, "Hz");
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => new OutputData(Enumerable.Range(0, (int)(b.TotalSeconds * (double)((IMeasurement)p["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)p["sampleRate"],
false),
(p) => Option <TimeSpan> .None());
var block = TimeSpan.FromMilliseconds(100);
IEnumerator <IOutputData> iter = s.DataBlocks(block).GetEnumerator();
int n = 0;
while (iter.MoveNext() && n < 100)
{
var expected =
new OutputData(
Enumerable.Range(0, (int)(block.TotalSeconds * (double)((IMeasurement)parameters["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)parameters["sampleRate"],
false);
Assert.That(iter.Current.Duration, Is.EqualTo(expected.Duration));
Assert.That(iter.Current.Data, Is.EqualTo(expected.Data));
n++;
}
}
public void DelegatesBlocks()
{
var parameters = new Dictionary<string, object>();
parameters["sampleRate"] = new Measurement(1000, "Hz");
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => new OutputData(Enumerable.Range(0, (int)(b.TotalSeconds * (double)((IMeasurement)p["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)p["sampleRate"],
false),
(p) => Option<TimeSpan>.None());
var block = TimeSpan.FromMilliseconds(100);
IEnumerator<IOutputData> iter = s.DataBlocks(block).GetEnumerator();
int n = 0;
while (iter.MoveNext() && n < 100)
{
var expected =
new OutputData(
Enumerable.Range(0, (int)(block.TotalSeconds * (double)((IMeasurement)parameters["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)parameters["sampleRate"],
false);
Assert.That(iter.Current.Duration, Is.EqualTo(expected.Duration));
Assert.That(iter.Current.Data, Is.EqualTo(expected.Data));
n++;
}
}
public void HoldsStimulusID()
{
var parameters = new Dictionary <string, object>();
string stimID = "my.ID";
var s = new DelegatedStimulus(stimID, "units",
parameters,
(p, b) => null,
(p) => Option <TimeSpan> .Some(TimeSpan.FromMilliseconds(0)));
Assert.That(s.StimulusID, Is.EqualTo(stimID));
}
public void HoldsStimulusID()
{
var parameters = new Dictionary<string, object>();
string stimID = "my.ID";
var s = new DelegatedStimulus(stimID, "units",
parameters,
(p, b) => null,
(p) => Option<TimeSpan>.Some(TimeSpan.FromMilliseconds(0)));
Assert.That(s.StimulusID, Is.EqualTo(stimID));
}
public void HoldsParameters()
{
var parameters = new Dictionary<string, object>();
parameters["key1"] = "value1";
parameters["key2"] = 2;
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => null,
(p) => Option<TimeSpan>.Some(TimeSpan.FromMilliseconds(0)));
Assert.That(s.Parameters, Is.EqualTo(parameters));
}
public void DelegatesDuration()
{
var parameters = new Dictionary<string, object>();
parameters["duration"] = TimeSpan.FromMilliseconds(617);
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => null,
(p) => Option<TimeSpan>.Some((TimeSpan)p["duration"]));
Assert.That((TimeSpan)s.Duration, Is.EqualTo(parameters["duration"]));
}
public void DelegatesDuration()
{
var parameters = new Dictionary <string, object>();
parameters["duration"] = TimeSpan.FromMilliseconds(617);
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => null,
(p) => Option <TimeSpan> .Some((TimeSpan)p["duration"]));
Assert.That((TimeSpan)s.Duration, Is.EqualTo(parameters["duration"]));
}
public void HoldsParameters()
{
var parameters = new Dictionary <string, object>();
parameters["key1"] = "value1";
parameters["key2"] = 2;
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => null,
(p) => Option <TimeSpan> .Some(TimeSpan.FromMilliseconds(0)));
Assert.That(s.Parameters, Is.EqualTo(parameters));
}
public void ShouldThrowForUnitMismatch()
{
var parameters = new Dictionary <string, object>();
parameters["sampleRate"] = new Measurement(1000, "Hz");
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => new OutputData(Enumerable.Range(0, (int)(b.TotalSeconds * (double)((IMeasurement)p["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "other")).ToList(),
(IMeasurement)p["sampleRate"],
false),
(p) => Option <TimeSpan> .None());
var block = TimeSpan.FromMilliseconds(100);
Assert.That(() => s.DataBlocks(block).GetEnumerator().MoveNext(), Throws.TypeOf(typeof(StimulusException)));
}
public void MaybeHasStartTime()
{
Epoch e = new Epoch("");
Assert.False(e.StartTime);
var dev = new UnitConvertingExternalDevice("name", "co", new Measurement(1.0m, "units"));
var stim = new DelegatedStimulus("stimID", "units", new Measurement(1000, "Hz"),
new Dictionary<string, object>(),
(p, b) => null,
(p) => Option<TimeSpan>.None());
e.Stimuli[dev] = stim;
var expected = DateTimeOffset.Now;
stim.DidOutputData(expected, TimeSpan.FromSeconds(1), null);
Assert.AreEqual(expected, (DateTimeOffset)e.StartTime);
}
public void SealLeak(
[Values(10000, 20000, 50000)] double sampleRate
)
{
Converters.Clear();
Converters.Register("V", "V",
// just an identity conversion for now, to pass Validate()
(IMeasurement m) => m);
HekaDAQInputStream.RegisterConverters();
HekaDAQOutputStream.RegisterConverters();
Assert.That(HekaDAQController.AvailableControllers().Count(), Is.GreaterThan(0));
foreach (var daq in HekaDAQController.AvailableControllers())
{
const double epochDuration = 10; //s
//Configure DAQ
daq.InitHardware();
try
{
daq.SampleRate = new Measurement((decimal)sampleRate, "Hz");
var controller = new Controller();
controller.Clock = daq.Clock;
controller.DAQController = daq;
const decimal expectedBackgroundVoltage = 3.2m;
var expectedBackground = new Measurement(expectedBackgroundVoltage, "V");
var dev0 = new UnitConvertingExternalDevice("Device0", "Manufacturer", controller, expectedBackground)
{
MeasurementConversionTarget = "V",
Clock = daq.Clock,
OutputSampleRate = daq.SampleRate,
InputSampleRate = daq.SampleRate
};
dev0.BindStream(daq.GetStreams("ao0").First() as IDAQOutputStream);
dev0.BindStream(daq.GetStreams("ai0").First() as IDAQInputStream);
controller.DiscardedEpoch += (c, args) => Console.WriteLine("Discarded epoch: " + args.Epoch);
// Setup Epoch
var e = new Epoch("HekaIntegration");
HekaDAQController cDAQ = daq;
var stim = new DelegatedStimulus("TEST_ID", "V", cDAQ.SampleRate, new Dictionary<string, object>(),
(parameters, duration) =>
DataForDuration(duration, cDAQ.SampleRate),
parameters => Option<TimeSpan>.None()
);
e.Stimuli[dev0] = stim;
e.Backgrounds[dev0] = new Background(expectedBackground, daq.SampleRate);
//Run single epoch
var fakeEpochPersistor = new FakeEpochPersistor();
new TaskFactory().StartNew(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(epochDuration));
controller.RequestStop();
},
TaskCreationOptions.LongRunning
);
controller.RunEpoch(e, fakeEpochPersistor);
}
finally
{
if (daq.IsHardwareReady)
daq.CloseHardware();
}
}
}
public void ShouldThrowForUnitMismatch()
{
var parameters = new Dictionary<string, object>();
parameters["sampleRate"] = new Measurement(1000, "Hz");
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => new OutputData(Enumerable.Range(0, (int)(b.TotalSeconds * (double)((IMeasurement)p["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "other")).ToList(),
(IMeasurement)p["sampleRate"],
false),
(p) => Option<TimeSpan>.None());
var block = TimeSpan.FromMilliseconds(100);
Assert.That(() => s.DataBlocks(block).GetEnumerator().MoveNext(), Throws.TypeOf(typeof(StimulusException)));
}
