test(pyargus): add tests comparing semantics against metric-temporal-logic

pyargus/tests/test_semantics.py

@@ -0,0 +1,89 @@
+from typing import List, Tuple
+
+import hypothesis.strategies as st
+import mtl
+from hypothesis import given
+
+import argus
+from argus.test_utils.signals_gen import gen_samples
+
+
+@given(
+    sample_lists=gen_samples(min_size=3, max_size=50, dtype_=bool, n_lists=2),
+    spec=st.one_of(
+        [
+            st.just(spec)
+            for spec in [
+                "a",
+                "~a",
+                "(a & b)",
+                "(a | b)",
+                "(a -> b)",
+                "(a <-> b)",
+                "(a ^ b)",
+            ]
+        ]
+    ),
+)
+def test_boolean_propositional_expr(
+    sample_lists: List[List[Tuple[float, bool]]],
+    spec: str,
+) -> None:
+    mtl_spec = mtl.parse(spec)
+    argus_spec = argus.parse_expr(spec)
+    assert isinstance(argus_spec, argus.BoolExpr)
+
+    a, b = sample_lists
+    mtl_data = dict(a=a, b=b)
+    argus_data = argus.Trace(
+        dict(
+            a=argus.BoolSignal.from_samples(a, interpolation_method="constant"),
+            b=argus.BoolSignal.from_samples(b, interpolation_method="constant"),
+        )
+    )
+
+    mtl_rob = mtl_spec(mtl_data, quantitative=False)
+    argus_rob = argus.eval_bool_semantics(argus_spec, argus_data)
+
+    assert mtl_rob == argus_rob.at(0), f"{argus_rob=}"
+
+
+@given(
+    sample_lists=gen_samples(min_size=3, max_size=50, dtype_=bool, n_lists=2),
+    spec=st.one_of(
+        [
+            st.just(spec)
+            for spec in [
+                "F a",
+                "G b",
+                "(G(a & b))",
+                "(F(a | b))",
+                "G(a -> F[0,2] b)",
+                "(a U b)",
+                "(a U[0,2] b)",
+            ]
+        ]
+    ),
+)
+def test_boolean_temporal_expr(
+    sample_lists: List[List[Tuple[float, bool]]],
+    spec: str,
+) -> None:
+    mtl_spec = mtl.parse(spec)
+    argus_spec = argus.parse_expr(spec)
+    assert isinstance(argus_spec, argus.BoolExpr)
+
+    a = sample_lists[0]
+    b = sample_lists[1]
+    mtl_data = dict(a=a, b=b)
+    argus_data = argus.Trace(
+        dict(
+            a=argus.BoolSignal.from_samples(a, interpolation_method="constant"),
+            b=argus.BoolSignal.from_samples(b, interpolation_method="constant"),
+        )
+    )
+
+    mtl_rob = mtl_spec(mtl_data, quantitative=False)
+    argus_rob = argus.eval_bool_semantics(argus_spec, argus_data)
+
+    assert mtl_rob == argus_rob.at(0), f"{argus_rob=}"

pyargus/tests/test_signals.py

@@ -29,7 +29,7 @@ def test_correct_constant_signals(data: st.DataObject) -> None:
 def test_correctly_create_signals(data: st.DataObject) -> None:
     dtype_ = data.draw(gen_dtype())
     xs = data.draw(gen_samples(min_size=0, max_size=100, dtype_=dtype_))
-    signal = sampled_signal(xs, dtype_)
+    signal = sampled_signal(xs, dtype_)  # type: ignore
     assert isinstance(signal, argus.Signal)
     if len(xs) > 0:
         expected_start_time = xs[0][0]
@@ -46,7 +46,7 @@ def test_correctly_create_signals(data: st.DataObject) -> None:
         a = data.draw(draw_index(xs))
         assert a < len(xs)
         at, expected_val = xs[a]
-        actual_val = signal.at(at)
+        actual_val = signal.at(at)  # type: ignore
 
         assert actual_val is not None
         assert actual_val == expected_val
@@ -79,10 +79,10 @@ def test_signal_create_should_fail(data: st.DataObject) -> None:
     assert a < len(xs)
     assert b < len(xs)
     # Swap two indices in the samples
-    xs[b], xs[a] = xs[a], xs[b]
+    xs[b], xs[a] = xs[a], xs[b]  # type: ignore
 
     with pytest.raises(RuntimeError, match=r"trying to create a non-monotonically signal.+"):
-        _ = sampled_signal(xs, dtype_)
+        _ = sampled_signal(xs, dtype_)  # type: ignore
 
 
 @given(st.data())