def test_sampling(self):
"""Test getting and setting the sampling."""
s = self.sensor
sampling.SampleNone(None, s)
sampling.SampleAuto(None, s)
sampling.SamplePeriod(None, s, 10)
sampling.SampleEvent(None, s)
sampling.SampleDifferential(None, s, 2)
self.assertRaises(ValueError, sampling.SampleNone, None, s, "foo")
self.assertRaises(ValueError, sampling.SampleAuto, None, s, "bar")
self.assertRaises(ValueError, sampling.SamplePeriod, None, s)
self.assertRaises(ValueError, sampling.SamplePeriod, None, s, "1.5")
self.assertRaises(ValueError, sampling.SamplePeriod, None, s, "-1")
self.assertRaises(ValueError, sampling.SampleEvent, None, s, "foo")
self.assertRaises(ValueError, sampling.SampleDifferential, None, s)
self.assertRaises(ValueError, sampling.SampleDifferential, None, s,
"-1")
self.assertRaises(ValueError, sampling.SampleDifferential, None, s,
"1.5")
sampling.SampleStrategy.get_strategy("none", None, s)
sampling.SampleStrategy.get_strategy("auto", None, s)
sampling.SampleStrategy.get_strategy("period", None, s, "15")
sampling.SampleStrategy.get_strategy("event", None, s)
sampling.SampleStrategy.get_strategy("differential", None, s, "2")
self.assertRaises(ValueError, sampling.SampleStrategy.get_strategy,
"random", None, s)
self.assertRaises(ValueError, sampling.SampleStrategy.get_strategy,
"period", None, s, "foo")
self.assertRaises(ValueError, sampling.SampleStrategy.get_strategy,
"differential", None, s, "bar")
def test_periodic(self):
"""Test reactor with periodic sampling."""
period = sampling.SamplePeriod(self.inform, self.sensor, 10)
start = time.time()
self.reactor.add_strategy(period)
time.sleep(0.1)
self.reactor.remove_strategy(period)
end = time.time()
expected = int(round((end - start) / 0.01))
emax, emin = expected + 1, expected - 1
self.assertTrue(
emin <= len(self.calls) <= emax,
"Expect %d to %d informs, got:\n %s" %
(emin, emax, "\n ".join(str(x) for x in self.calls)))
def test_periodic(self):
"""Test SamplePeriod strategy."""
# period = 10s
period = sampling.SamplePeriod(self.inform, self.sensor, 10000)
self.assertEqual(self.calls, [])
period.attach()
self.assertEqual(self.calls, [])
period.periodic(1)
self.assertEqual(len(self.calls), 1)
period.periodic(11)
self.assertEqual(len(self.calls), 2)
period.periodic(12)
self.assertEqual(len(self.calls), 3)
def test_periodic(self):
"""Test reactor with periodic sampling."""
period = 10.
no_periods = 5
period_strat = sampling.SamplePeriod(self.inform, self.sensor, period)
self._add_strategy(period_strat)
for i in range(no_periods):
self.timewarp(period, event_to_await=self.inform_called)
self.reactor.remove_strategy(period_strat)
call_times = [t for t, vals in self.calls]
self.assertEqual(len(self.calls), no_periods + 1)
self.assertEqual(call_times,
[self.start_time + i*period
for i in range(no_periods + 1)])
def test_periodic(self):
t0 = self.ioloop_time
sample_p = 10 # sample DUT in seconds
DUT = sampling.SamplePeriod(self.inform, self.sensor, sample_p)
self.assertEqual(DUT.get_sampling_formatted(), (b'period', [b'10']))
self.assertEqual(self.calls, [])
t, status, value = self.sensor.read()
DUT.start()
yield self.wake_ioloop()
self.assertEqual(self.calls, [(self.sensor, (t, status, value))])
self.calls = []
# Warp the ioloop clock forward a bit more than one DUT. Check that
# 1) a sample is sent,
# 2) the next sample is scheduled at t0+DUT, not t0+DUT+extra delay
yield self.set_ioloop_time(t0 + sample_p * 1.15)
self.assertEqual(self.calls, [(self.sensor, (t, status, value))])
self.calls = []
# Don't expect an update, since we are at just before the next sample DUT
yield self.set_ioloop_time(t0 + sample_p * 1.99)
self.assertEqual(self.calls, [])
# Now we are at exactly the next sample time, expect update
yield self.set_ioloop_time(t0 + sample_p * 2)
self.assertEqual(self.calls, [(self.sensor, (t, status, value))])
self.calls = []
# Bit past previous sample time, expect no update
yield self.set_ioloop_time(t0 + sample_p * 2.16)
self.assertEqual(self.calls, [])
# Check that no update is sent if the sensor is updated, but that the next
# periodic update is correct
t, status, value = (t0 + sample_p * 2.5, Sensor.WARN, -1)
self.sensor.set(t, status, value)
yield self.set_ioloop_time(t0 + sample_p * 2.6)
self.assertEqual(self.calls, [])
yield self.set_ioloop_time(t0 + sample_p * 3)
self.assertEqual(self.calls, [(self.sensor, (t, status, value))])
self.calls = []
# Cancel strategy and check that its timeout call is cancelled.
DUT.cancel()
yield self.wake_ioloop()
yield self.set_ioloop_time(t0 + sample_p * 4.1)
self.assertEqual(self.calls, [])
def test_periodic(self):
"""Test SamplePeriod strategy."""
sample_p = 10 # sample period in seconds
period = sampling.SamplePeriod(self.inform, self.sensor, sample_p)
self.assertEqual(self.calls, [])
period.attach()
self.assertEqual(self.calls, [])
next_p = period.periodic(1)
self.assertEqual(next_p, 1 + sample_p)
self.assertEqual(len(self.calls), 1)
next_p = period.periodic(11)
self.assertEqual(len(self.calls), 2)
self.assertEqual(next_p, 11 + sample_p)
next_p = period.periodic(12)
self.assertEqual(next_p, 12 + sample_p)
self.assertEqual(len(self.calls), 3)
