def test_resolve_inifitesimal_resolve_greater_minus_plus_eps(self):
i = tctl.Interval()
i >= (1 - eps)
i <= 7
exp = tctl.Interval()
exp >= 1
exp <= 7
self.assertEqual(i.resolve_infinitesimal(), exp)
def test_resolve_inifitesimal_resolve_greater_equals_plus_eps(self):
i = tctl.Interval()
i >= (3 + eps)
i <= 4
exp = tctl.Interval()
exp > 3
exp <= 4
self.assertEqual(i.resolve_infinitesimal(), exp)
def test_resolve_inifitesimal_resolve_lower_equals_minus_eps(self):
i = tctl.Interval()
i >= 2
i <= (9 - eps)
exp = tctl.Interval()
exp >= 2
exp < 9
self.assertEqual(i.resolve_infinitesimal(), exp)
def test_operatorEquals_onEqualIntervals_discoversDifferentEnd(self):
i1 = tctl.Interval()
i1 >= 10
i1 <= 31
i2 = tctl.Interval()
i2 >= 10
i2 <= 30
self.assertFalse(i1.compare(i2))
def test_operatorEquals_onEqualIntervals(self):
i1 = tctl.Interval()
i1 >= 10
i1 <= 30
i2 = tctl.Interval()
i2 >= 10
i2 <= 30
self.assertTrue(i1.compare(i2))
def test_operatorEquals_onEqualIntervals_differentDatatypes(self):
i1 = tctl.Interval()
i1 >= 10.0
i1 <= 30
i2 = tctl.Interval()
i2 >= 10
i2 <= 30.0
self.assertTrue(i1.compare(i2))
def test_resolve_inifitesimal_resolve_lower_equals_plus_eps(self):
i = tctl.Interval()
i >= 0
i <= (5 + eps)
exp = tctl.Interval()
exp >= 0
exp <= 5
self.assertEqual(i.resolve_infinitesimal(), exp)
def test_operatorLowerEquals_setsEndAndEndOperator(self):
i = tctl.Interval()
i <= 22
self.assertEqual(i.end, 22, "End operator correctly set")
self.assertEqual(i.end_operator, operator.le,
"End operator correctly set")
def test_operatorGreater_setsStartAndStartOperator(self):
i = tctl.Interval()
i > 17
self.assertEqual(i.start, 17, "Start operator correctly set")
self.assertEqual(i.start_operator, operator.gt,
"Start operator correctly set")
def test_need_transformation_timed_formula_other_interval(
self, statespace):
ap = NamedAtomicProposition("myAP")
formula = tctl.EG(ap, interval=(tctl.Interval() <= 15))
mc = ContinuousModelChecker(statespace)
self.assertTrue(mc.need_transformation(formula))
def test_need_transformation_timed_formula_modified_interval_operators(
self, statespace):
ap = NamedAtomicProposition("myAP")
formula = tctl.EG(ap, interval=(tctl.Interval() <= math.inf) > 0)
mc = ContinuousModelChecker(statespace)
self.assertFalse(mc.need_transformation(formula))
def test_operatorGreaterEquals_setsStartAndStartOperator(self):
i = tctl.Interval()
i >= 24
self.assertEqual(i.start, 24, "Start operator correctly set")
self.assertEqual(i.start_operator, operator.ge,
"Start operator correctly set")
def test_operatorLower_setsEndAndEndOperator(self):
i = tctl.Interval()
i < 15
self.assertEqual(i.end, 15, "End operator correctly set")
self.assertEqual(i.end_operator, operator.lt,
"Default end operator is correct")
def test_default(self):
i = tctl.Interval()
self.assertEqual(i.start, 0, "Default start is correct")
self.assertEqual(i.start_operator, operator.ge,
"Default start operator is correct")
self.assertEqual(i.end, math.inf, "Default end is correct")
self.assertEqual(i.end_operator, operator.lt,
"Default end operator is correct")
def test_formula_creation_with_after(self):
ap = NamedAtomicProposition("myAP")
verifier = verif.is_possible(ap).after(52)
exp = tctl.EF(ap, interval=tctl.Interval() > 52)
got = verifier.formula
self.assertTrue(exp.eq(got))
def test_always_possible_within_formula(self):
ap = NamedAtomicProposition("myAP")
verifier = verif.always_possible(ap, within=30)
exp = tctl.AG(tctl.AF(ap, interval=tctl.Interval() <= 30))
got = verifier.formula
self.assertTrue(exp.eq(got))
def test_operatorIAdd_finiteEnd_addsToStartAndEnd(self):
i = tctl.Interval()
i.start = 10
i.end = 20
i += 33
self.assertEqual(i.start, 43, "+= set the correct start value")
self.assertEqual(i.end, 53, "+= set the correct end value")
def test_operatorISub_finiteEnd_subsFromStartAndEnd(self):
i = tctl.Interval()
i.start = 10
i.end = 20
i -= 7
self.assertEqual(i.start, 3, "-= set the correct start value")
self.assertEqual(i.end, 13, "-= set the correct end value")
def test_operatorIAdd_infiniteEnd_addsToStartButNotEnd(self):
i = tctl.Interval()
i.start = 12
i.end = math.inf
i += 33
self.assertEqual(i.start, 45, "+= set the correct start value")
self.assertEqual(i.end, math.inf, "+= set the correct end value")
def test_operatorISub_infiniteEnd_subsFromStartButNotEnd(self):
i = tctl.Interval()
i.start = 77
i.end = math.inf
i -= 7
self.assertEqual(i.start, 70, "-= set the correct start value")
self.assertEqual(i.end, math.inf, "-= set the correct end value")
def test_calling_correct_procedure(self):
"""
This testroutine mocks the procedure implementations and
verifies that the correct mock is called, depending on the formula.
"""
mc = PointwiseModelChecker(self.ss)
tl = check(self.system.timer) < 5
tvl = check(self.system.timer) <= 3
paramlist = {
(tctl.EU(tl, tvl), "Sat_EU"),
(tctl.EG(tl), "Sat_EG"),
(tctl.EU(tl, tvl, tctl.Interval(end=25,
end_op=operator.le)), "Sat_EUb"),
(tctl.EU(tl, tvl, tctl.Interval(end=25,
end_op=operator.lt)), "Sat_EUb"),
(tctl.EU(tl, tvl, tctl.Interval(start=5,
start_op=operator.ge)), "Sat_EUa"),
(tctl.EU(tl, tvl, tctl.Interval(start=5,
start_op=operator.gt)), "Sat_EUa"),
(tctl.EU(
tl, tvl,
tctl.Interval(start=5,
start_op=operator.ge,
end=25,
end_op=operator.le)), "Sat_EUab"),
(tctl.EU(
tl, tvl,
tctl.Interval(start=5,
start_op=operator.gt,
end=25,
end_op=operator.le)), "Sat_EUab"),
(tctl.EU(
tl, tvl,
tctl.Interval(start=5,
start_op=operator.ge,
end=25,
end_op=operator.lt)), "Sat_EUab"),
(tctl.EU(
tl, tvl,
tctl.Interval(start=5,
start_op=operator.gt,
end=25,
end_op=operator.lt)), "Sat_EUab"),
(tctl.AU(
tl, tvl,
tctl.Interval(start=0,
start_op=operator.gt,
end=math.inf,
end_op=operator.lt)), "Sat_AU0"),
(tctl.AU(
tl, tvl,
tctl.Interval(start=0,
start_op=operator.gt,
end=25,
end_op=operator.le)), "Sat_AU0"),
(tctl.AU(
tl, tvl,
tctl.Interval(start=0,
start_op=operator.gt,
end=25,
end_op=operator.lt)), "Sat_AU0"),
}
for formula, method in paramlist:
with self.subTest():
setattr(mc, method, mock.MagicMock())
res = mc.is_satisfiable(formula, None)
getattr(mc, method).assert_called_once()
