def test_get_metadata_key_ranges(self):
experiment = m.Experiment(
os.path.join(ud.UData().Basedir, "foo.myrmidon"))
experiment.SetMetaDataKey("alive", True)
experiment.CreateAnt()
a = experiment.CreateAnt()
a.SetValue(key="alive", value=False, time=m.Time())
a = experiment.CreateAnt()
a.SetValue(key="alive", value=False, time=m.Time.SinceEver())
a.SetValue(key="alive", value=True, time=m.Time())
a.SetValue(key="alive", value=True, time=m.Time().Add(1))
a.SetValue(key="alive", value=False, time=m.Time().Add(2))
a.SetValue(key="alive", value=True, time=m.Time().Add(3))
ranges = m.Query.GetMetaDataKeyRanges(experiment,
key="alive",
value=True)
self.assertEqual(len(ranges), 4)
self.assertEqual(ranges[0], (1, m.Time.SinceEver(), m.Time.Forever()))
self.assertEqual(ranges[1], (2, m.Time.SinceEver(), m.Time()))
self.assertEqual(ranges[2], (3, m.Time(), m.Time().Add(2)))
self.assertEqual(ranges[3], (3, m.Time().Add(3), m.Time.Forever()))
with self.assertRaises(IndexError):
m.Query.GetMetaDataKeyRanges(experiment, key="isDead", value=True)
with self.assertRaises(ValueError):
m.Query.GetMetaDataKeyRanges(experiment, key="alive", value=42.0)
def test_has_infinite_support(self):
self.assertEqual(m.Time.SinceEver().ToTimestamp(), float('-inf'))
self.assertEqual(m.Time.Forever().ToTimestamp(), float('inf'))
self.assertEqual(m.Time(float('-inf')), m.Time.SinceEver())
self.assertEqual(m.Time(float('inf')), m.Time.Forever())
self.assertTrue(m.Time.Forever().IsInfinite())
self.assertTrue(m.Time.Forever().IsForever())
self.assertFalse(m.Time.Forever().IsSinceEver())
self.assertTrue(m.Time.SinceEver().IsInfinite())
self.assertFalse(m.Time.SinceEver().IsForever())
self.assertTrue(m.Time.SinceEver().IsSinceEver())
def test_identification_manipulation(self):
ants = [self.experiment.CreateAnt(), self.experiment.CreateAnt()]
with self.assertRaises(IndexError):
self.experiment.AddIdentification(42, 0, m.Time.SinceEver(),
m.Time.Forever())
self.experiment.AddIdentification(ants[0].ID, 0, m.Time.SinceEver(),
m.Time.Forever())
with self.assertRaises(m.OverlappingIdentification):
self.experiment.AddIdentification(ants[0].ID, 1,
m.Time.SinceEver(),
m.Time.Forever())
with self.assertRaises(m.OverlappingIdentification):
self.experiment.AddIdentification(ants[1].ID, 0,
m.Time.SinceEver(),
m.Time.Forever())
self.experiment.AddIdentification(ants[1].ID, 1, m.Time.SinceEver(),
m.Time.Forever())
e2 = m.Experiment("foo.myrmidon")
a2 = e2.CreateAnt()
i2 = e2.AddIdentification(a2.ID, 0, m.Time.SinceEver(),
m.Time.Forever())
with self.assertRaises(ValueError):
self.experiment.DeleteIdentification(i2)
ants[0].Identifications[0].End = m.Time()
with self.assertRaises(RuntimeError):
self.experiment.FreeIdentificationRangeAt(
ants[0].Identifications[0].TagValue,
m.Time().Add(-1))
low, high = self.experiment.FreeIdentificationRangeAt(
ants[0].Identifications[0].TagValue, m.Time())
self.assertTimeEqual(low, m.Time())
self.assertTimeEqual(high, m.Time.Forever())
low, high = self.experiment.FreeIdentificationRangeAt(42, m.Time())
self.assertTimeEqual(low, m.Time.SinceEver())
self.assertTimeEqual(high, m.Time.Forever())
identifications = self.experiment.IdentificationsAt(
time=m.Time().Add(-1), removeUnidentifiedAnt=True)
self.assertEqual(len(identifications), 2)
self.assertEqual(identifications[ants[0].ID], 0)
self.assertEqual(identifications[ants[1].ID], 1)
identifications = self.experiment.IdentificationsAt(
time=m.Time(), removeUnidentifiedAnt=True)
self.assertEqual(len(identifications), 1)
self.assertEqual(identifications[ants[1].ID], 1)
self.assertFalse(ants[0].ID in identifications)
identifications = self.experiment.IdentificationsAt(
time=m.Time(), removeUnidentifiedAnt=False)
self.assertEqual(len(identifications), 2)
self.assertEqual(identifications[ants[0].ID], 2**32 - 1)
self.assertEqual(identifications[ants[1].ID], 1)
def test_has_math_support(self):
t = m.Time.Now().Round(m.Duration.Second)
# we makes a deep copy of the time we use by passing it forth
# and back to a float
u = m.Time(t.ToDateTime())
self.assertEqual(t.Add(1).Sub(t), 1)
self.assertEqual(
t.Add(1 * m.Duration.Second).Sub(t), m.Duration.Second)
# we can use the verbose comparators Equals/After/Before or
# the overloaded operators
self.assertFalse(t > t)
self.assertFalse(t.After(t))
self.assertFalse(t < t)
self.assertFalse(t.Before(t))
self.assertTrue(t.Add(1) > t)
self.assertTrue(t.Add(1).After(t))
self.assertFalse(t > t.Add(1))
self.assertFalse(t.After(t.Add(1)))
self.assertTrue(t == t)
self.assertTrue(t.Equals(t))
# all modification did not modify the original t
self.assertEqual(t, u)
def test_datetime_conversion(self):
# create a datetime from UTC, and convert it to localtime
d = datetime.datetime.fromisoformat(
"2019-11-02T23:12:13.000014+00:00").astimezone(None)
t = m.Time(d)
self.assertEqual(t, m.Time.Parse("2019-11-02T23:12:13.000014Z"))
self.assertEqual(d, t.ToDateTime().astimezone(None))
def test_infinite_time_computation_overflow(self):
operations = [
(lambda: m.Time.Forever().Add(0), False),
(lambda: m.Time.Forever().Add(1), True),
(lambda: m.Time.Forever().Add(-1), True),
(lambda: m.Time.SinceEver().Add(0), False),
(lambda: m.Time.SinceEver().Add(1), True),
(lambda: m.Time.SinceEver().Add(-1), True),
(lambda: m.Time.SinceEver().Sub(m.Time()), True),
(lambda: m.Time.SinceEver().Sub(m.Time()), True),
]
for op, hasError in operations:
if hasError:
with self.assertRaises(RuntimeError):
op()
else:
op()
def test_infinite_time_comparisons(self):
data = [
m.Time(),
m.Time().Add(2**63 - 1),
m.Time().Add(-2**63),
]
for t in data:
self.assertTrue(t < m.Time.Forever())
self.assertTrue(t > m.Time.SinceEver())
self.assertFalse(m.Time.Forever() > m.Time.Forever())
self.assertFalse(m.Time.Forever() < m.Time.Forever())
self.assertTrue(m.Time.Forever() == m.Time.Forever())
self.assertFalse(m.Time.SinceEver() > m.Time.SinceEver())
self.assertFalse(m.Time.SinceEver() < m.Time.SinceEver())
self.assertTrue(m.Time.SinceEver() == m.Time.SinceEver())
def test_time_parsing(self):
self.assertEqual(
m.Time.Parse("1970-01-02T01:02:03.004Z"),
m.Time().Add(25 * m.Duration.Hour + 2 * m.Duration.Minute +
3 * m.Duration.Second + 4 * m.Duration.Millisecond))
with self.assertRaises(RuntimeError):
m.Time.Parse("-∞")
with self.assertRaises(RuntimeError):
m.Time.Parse("+∞")
def test_zone_definition_manipulation(self):
zone = self.space.CreateZone("exit")
definitions = [
zone.AddDefinition([], start=m.Time()),
zone.AddDefinition([], end=m.Time()),
]
with self.assertRaises(RuntimeError):
zone.AddDefinition([],
start=m.Time().Add(-1),
end=m.Time().Add(1))
self.assertEqual(len(zone.Definitions), 2)
self.assertEqual(zone.Definitions[0], definitions[1])
self.assertEqual(zone.Definitions[1], definitions[0])
with self.assertRaises(IndexError):
zone.DeleteDefinition(42)
zone.DeleteDefinition(0)
self.assertEqual(zone.Definitions[0], definitions[0])
def test_time_manipulation(self):
self.experiment.DeleteIdentification(self.i)
self.i = None
idents = [
self.experiment.AddIdentification(self.ant.ID, 123, end=m.Time()),
self.experiment.AddIdentification(self.ant.ID, 124,
start=m.Time()),
]
self.assertTimeEqual(idents[0].Start, m.Time.SinceEver())
self.assertTimeEqual(idents[0].End, m.Time())
self.assertTimeEqual(idents[1].Start, m.Time())
self.assertTimeEqual(idents[1].End, m.Time.Forever())
with self.assertRaises(m.OverlappingIdentification):
idents[0].End = m.Time().Add(1)
with self.assertRaises(m.OverlappingIdentification):
idents[1].Start = m.Time().Add(-1)
idents[0].End = m.Time().Add(-1)
idents[1].Start = m.Time().Add(1)
self.assertTimeEqual(idents[0].End, m.Time().Add(-1))
self.assertTimeEqual(idents[1].Start, m.Time().Add(1))
def test_zone_definition_have_time_validity(self):
zone = self.space.CreateZone("food")
definitions = [
zone.AddDefinition([], end=m.Time()),
zone.AddDefinition([], start=m.Time()),
]
with self.assertRaises(ValueError):
zone.AddDefinition([],
start=m.Time.Forever(),
end=m.Time.SinceEver())
with self.assertRaises(RuntimeError):
definitions[0].End = m.Time().Add(1)
with self.assertRaises(RuntimeError):
definitions[1].Start = m.Time().Add(-1)
definitions[0].End = m.Time().Add(-1)
definitions[1].Start = m.Time().Add(1)
zone.AddDefinition([],
start=m.Time().Add(-1),
end=m.Time().Add(1))
def test_meta_data_key_manipulation(self):
self.experiment.SetMetaDataKey("alive", True)
self.experiment.SetMetaDataKey("group", "worker")
self.assertEqual(len(self.experiment.MetaDataKeys), 2)
self.assertTrue("alive" in self.experiment.MetaDataKeys)
self.assertTrue("group" in self.experiment.MetaDataKeys)
self.assertEqual(self.experiment.MetaDataKeys["alive"], True)
self.assertEqual(self.experiment.MetaDataKeys["group"], "worker")
a = self.experiment.CreateAnt()
a.SetValue(key="group", value="nurse", time=m.Time.SinceEver())
with self.assertRaises(IndexError):
self.experiment.DeleteMetaDataKey("foo")
with self.assertRaises(RuntimeError):
self.experiment.DeleteMetaDataKey("group")
with self.assertRaises(IndexError):
self.experiment.RenameMetaDataKey(oldKey="foo", newKey="bar")
with self.assertRaises(ValueError):
self.experiment.RenameMetaDataKey(oldKey="alive", newKey="group")
self.experiment.RenameMetaDataKey(oldKey="alive", newKey="death-date")
self.experiment.SetMetaDataKey("death-date", m.Time.Forever())
self.experiment.DeleteMetaDataKey("death-date")
self.experiment.SetMetaDataKey("group", "forager")
with self.assertRaises(RuntimeError):
self.experiment.SetMetaDataKey("group", 42)
a.SetValue(key="group", value="forager", time=m.Time())
a.SetValue(key="group", value="worker", time=m.Time().Add(1))
self.experiment.SetMetaDataKey("group", "worker")
self.assertEqual(a.GetValue("group", m.Time()), "worker")
self.assertEqual(a.GetValue("group", m.Time().Add(1)), "worker")
a.DeleteValue("group", m.Time.SinceEver())
a.DeleteValue("group", m.Time())
a.DeleteValue("group", m.Time().Add(1))
self.experiment.SetMetaDataKey("group", 42)
self.assertEqual(self.experiment.MetaDataKeys["group"], 42)
def test_time_infinite_rounding_is_noop(self):
self.assertTrue(m.Time.Forever().Round(0).Equals(m.Time().Forever()))
self.assertTrue(m.Time.SinceEver().Round(0).Equals(
m.Time().SinceEver()))
def test_constructor(self):
self.assertEqual(m.Time(), m.Time(0.0))
self.assertEqual(m.Time(), 0.0)
def test_time_overflow(self):
with self.assertRaises(RuntimeError):
m.Time(2.0**64)
def test_scope_vailidity(self):
a = self.experiment.CreateAnt()
self.experiment.SetMetaDataKey("alive", True)
self.experiment = None
a.SetValue("alive", False, m.Time())
def test_scope_validity(self):
self.experiment = None
self.ant = None
self.i.Start = m.Time()
def test_can_identify_ants(self):
self.assertEqual(self.solver.IdentifyAnt(0, m.Time()), 1)
self.assertEqual(self.solver.IdentifyAnt(1, m.Time()), 2)
self.assertEqual(self.solver.IdentifyAnt(2, m.Time()), 3)
self.assertEqual(self.solver.IdentifyAnt(123, m.Time()), 0)
