wip

cereal/messaging/tests/test_fake.py

@@ -0,0 +1,193 @@
+import os
+import unittest
+import multiprocessing
+import platform
+from parameterized import parameterized_class
+from typing import Optional
+
+import cereal.messaging as messaging
+
+WAIT_TIMEOUT = 5
+
+
+@unittest.skipIf(platform.system() == "Darwin", "Events not supported on macOS")
+class TestEvents(unittest.TestCase):
+
+  def test_mutation(self):
+    handle = messaging.fake_event_handle("carState")
+    event = handle.recv_called_event
+
+    self.assertFalse(event.peek())
+    event.set()
+    self.assertTrue(event.peek())
+    event.clear()
+    self.assertFalse(event.peek())
+
+    del event
+
+  def test_wait(self):
+    handle = messaging.fake_event_handle("carState")
+    event = handle.recv_called_event
+
+    event.set()
+    try:
+      event.wait(WAIT_TIMEOUT)
+      self.assertTrue(event.peek())
+    except RuntimeError:
+      self.fail("event.wait() timed out")
+
+  def test_wait_multiprocess(self):
+    handle = messaging.fake_event_handle("carState")
+    event = handle.recv_called_event
+
+    def set_event_run():
+      event.set()
+
+    try:
+      p = multiprocessing.Process(target=set_event_run)
+      p.start()
+      event.wait(WAIT_TIMEOUT)
+      self.assertTrue(event.peek())
+    except RuntimeError:
+      self.fail("event.wait() timed out")
+
+    p.kill()
+
+  def test_wait_zero_timeout(self):
+    handle = messaging.fake_event_handle("carState")
+    event = handle.recv_called_event
+
+    try:
+      event.wait(0)
+      self.fail("event.wait() did not time out")
+    except RuntimeError:
+      self.assertFalse(event.peek())
+
+
+@unittest.skipIf(platform.system() == "Darwin", "FakeSockets not supported on macOS")
+@unittest.skipIf("ZMQ" in os.environ, "FakeSockets not supported on ZMQ")
+@parameterized_class([{"prefix": None}, {"prefix": "test"}])
+class TestFakeSockets(unittest.TestCase):
+  prefix: Optional[str] = None
+
+  def setUp(self):
+    messaging.toggle_fake_events(True)
+    if self.prefix is not None:
+      messaging.set_fake_prefix(self.prefix)
+    else:
+      messaging.delete_fake_prefix()
+
+  def tearDown(self):
+    messaging.toggle_fake_events(False)
+    messaging.delete_fake_prefix()
+
+  def test_event_handle_init(self):
+    handle = messaging.fake_event_handle("controlsState", override=True)
+
+    self.assertFalse(handle.enabled)
+    self.assertGreaterEqual(handle.recv_called_event.fd, 0)
+    self.assertGreaterEqual(handle.recv_ready_event.fd, 0)
+
+  def test_non_managed_socket_state(self):
+    # non managed socket should have zero state
+    _ = messaging.pub_sock("ubloxGnss")
+
+    handle = messaging.fake_event_handle("ubloxGnss", override=False)
+
+    self.assertFalse(handle.enabled)
+    self.assertEqual(handle.recv_called_event.fd, 0)
+    self.assertEqual(handle.recv_ready_event.fd, 0)
+
+  def test_managed_socket_state(self):
+    # managed socket should not change anything about the state
+    handle = messaging.fake_event_handle("ubloxGnss")
+    handle.enabled = True
+
+    expected_enabled = handle.enabled
+    expected_recv_called_fd = handle.recv_called_event.fd
+    expected_recv_ready_fd = handle.recv_ready_event.fd
+
+    _ = messaging.pub_sock("ubloxGnss")
+
+    self.assertEqual(handle.enabled, expected_enabled)
+    self.assertEqual(handle.recv_called_event.fd, expected_recv_called_fd)
+    self.assertEqual(handle.recv_ready_event.fd, expected_recv_ready_fd)
+
+  def test_sockets_enable_disable(self):
+    carState_handle = messaging.fake_event_handle("ubloxGnss", enable=True)
+    recv_called = carState_handle.recv_called_event
+    recv_ready = carState_handle.recv_ready_event
+
+    pub_sock = messaging.pub_sock("ubloxGnss")
+    sub_sock = messaging.sub_sock("ubloxGnss")
+
+    try:
+      carState_handle.enabled = True
+      recv_ready.set()
+      pub_sock.send(b"test")
+      _ = sub_sock.receive()
+      self.assertTrue(recv_called.peek())
+      recv_called.clear()
+
+      carState_handle.enabled = False
+      recv_ready.set()
+      pub_sock.send(b"test")
+      _ = sub_sock.receive()
+      self.assertFalse(recv_called.peek())
+    except RuntimeError:
+      self.fail("event.wait() timed out")
+
+  def test_synced_pub_sub(self):
+    def daemon_repub_process_run():
+      pub_sock = messaging.pub_sock("ubloxGnss")
+      sub_sock = messaging.sub_sock("carState")
+
+      frame = -1
+      while True:
+        frame += 1
+        msg = sub_sock.receive(non_blocking=True)
+        if msg is None:
+          print("none received")
+          continue
+
+        bts = frame.to_bytes(8, 'little')
+        pub_sock.send(bts)
+
+    carState_handle = messaging.fake_event_handle("carState", enable=True)
+    recv_called = carState_handle.recv_called_event
+    recv_ready = carState_handle.recv_ready_event
+
+    p = multiprocessing.Process(target=daemon_repub_process_run)
+    p.start()
+
+    pub_sock = messaging.pub_sock("carState")
+    sub_sock = messaging.sub_sock("ubloxGnss")
+
+    try:
+      for i in range(10):
+        recv_called.wait(WAIT_TIMEOUT)
+        recv_called.clear()
+
+        if i == 0:
+          sub_sock.receive(non_blocking=True)
+
+        bts = i.to_bytes(8, 'little')
+        pub_sock.send(bts)
+
+        recv_ready.set()
+        recv_called.wait(WAIT_TIMEOUT)
+
+        msg = sub_sock.receive(non_blocking=True)
+        self.assertIsNotNone(msg)
+        self.assertEqual(len(msg), 8)
+
+        frame = int.from_bytes(msg, 'little')
+        self.assertEqual(frame, i)
+    except RuntimeError:
+      self.fail("event.wait() timed out")
+    finally:
+      p.kill()
+
+
+if __name__ == "__main__":
+  unittest.main()

cereal/messaging/tests/test_messaging.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+import os
+import capnp
+import multiprocessing
+import numbers
+import random
+import threading
+import time
+import unittest
+from parameterized import parameterized
+
+from cereal import log, car
+import cereal.messaging as messaging
+from cereal.services import SERVICE_LIST
+
+events = [evt for evt in log.Event.schema.union_fields if evt in SERVICE_LIST.keys()]
+
+def random_sock():
+  return random.choice(events)
+
+def random_socks(num_socks=10):
+  return list({random_sock() for _ in range(num_socks)})
+
+def random_bytes(length=1000):
+  return bytes([random.randrange(0xFF) for _ in range(length)])
+
+def zmq_sleep(t=1):
+  if "ZMQ" in os.environ:
+    time.sleep(t)
+
+def zmq_expected_failure(func):
+  if "ZMQ" in os.environ:
+    return unittest.expectedFailure(func)
+  else:
+    return func
+
+# TODO: this should take any capnp struct and returrn a msg with random populated data
+def random_carstate():
+  fields = ["vEgo", "aEgo", "gas", "steeringAngleDeg"]
+  msg = messaging.new_message("carState")
+  cs = msg.carState
+  for f in fields:
+    setattr(cs, f, random.random() * 10)
+  return msg
+
+# TODO: this should compare any capnp structs
+def assert_carstate(cs1, cs2):
+  for f in car.CarState.schema.non_union_fields:
+    # TODO: check all types
+    val1, val2 = getattr(cs1, f), getattr(cs2, f)
+    if isinstance(val1, numbers.Number):
+      assert val1 == val2, f"{f}: sent '{val1}' vs recvd '{val2}'"
+
+def delayed_send(delay, sock, dat):
+  def send_func():
+    sock.send(dat)
+  threading.Timer(delay, send_func).start()
+
+class TestPubSubSockets(unittest.TestCase):
+
+  def setUp(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep()
+
+  def test_pub_sub(self):
+    sock = random_sock()
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, conflate=False, timeout=None)
+    zmq_sleep(3)
+
+    for _ in range(1000):
+      msg = random_bytes()
+      pub_sock.send(msg)
+      recvd = sub_sock.receive()
+      self.assertEqual(msg, recvd)
+
+  def test_conflate(self):
+    sock = random_sock()
+    pub_sock = messaging.pub_sock(sock)
+    for conflate in [True, False]:
+      for _ in range(10):
+        num_msgs = random.randint(3, 10)
+        sub_sock = messaging.sub_sock(sock, conflate=conflate, timeout=None)
+        zmq_sleep()
+
+        sent_msgs = []
+        for __ in range(num_msgs):
+          msg = random_bytes()
+          pub_sock.send(msg)
+          sent_msgs.append(msg)
+        time.sleep(0.1)
+        recvd_msgs = messaging.drain_sock_raw(sub_sock)
+        if conflate:
+          self.assertEqual(len(recvd_msgs), 1)
+        else:
+          # TODO: compare actual data
+          self.assertEqual(len(recvd_msgs), len(sent_msgs))
+
+  def test_receive_timeout(self):
+    sock = random_sock()
+    for _ in range(10):
+      timeout = random.randrange(200)
+      sub_sock = messaging.sub_sock(sock, timeout=timeout)
+      zmq_sleep()
+
+      start_time = time.monotonic()
+      recvd = sub_sock.receive()
+      self.assertLess(time.monotonic() - start_time, 0.2)
+      assert recvd is None
+
+class TestMessaging(unittest.TestCase):
+
+  def setUp(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep()
+
+  @parameterized.expand(events)
+  def test_new_message(self, evt):
+    try:
+      msg = messaging.new_message(evt)
+    except capnp.lib.capnp.KjException:
+      msg = messaging.new_message(evt, random.randrange(200))
+    self.assertLess(time.monotonic() - msg.logMonoTime, 0.1)
+    self.assertFalse(msg.valid)
+    self.assertEqual(evt, msg.which())
+
+  @parameterized.expand(events)
+  def test_pub_sock(self, evt):
+    messaging.pub_sock(evt)
+
+  @parameterized.expand(events)
+  def test_sub_sock(self, evt):
+    messaging.sub_sock(evt)
+
+  @parameterized.expand([
+    (messaging.drain_sock, capnp._DynamicStructReader),
+    (messaging.drain_sock_raw, bytes),
+  ])
+  def test_drain_sock(self, func, expected_type):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=1000)
+    zmq_sleep()
+
+    # no wait and no msgs in queue
+    msgs = func(sub_sock)
+    self.assertIsInstance(msgs, list)
+    self.assertEqual(len(msgs), 0)
+
+    # no wait but msgs are queued up
+    num_msgs = random.randrange(3, 10)
+    for _ in range(num_msgs):
+      pub_sock.send(messaging.new_message(sock).to_bytes())
+    time.sleep(0.1)
+    msgs = func(sub_sock)
+    self.assertIsInstance(msgs, list)
+    self.assertTrue(all(isinstance(msg, expected_type) for msg in msgs))
+    self.assertEqual(len(msgs), num_msgs)
+
+  def test_recv_sock(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=100)
+    zmq_sleep()
+
+    # no wait and no msg in queue, socket should timeout
+    recvd = messaging.recv_sock(sub_sock)
+    self.assertTrue(recvd is None)
+
+    # no wait and one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    time.sleep(0.01)
+    recvd = messaging.recv_sock(sub_sock)
+    self.assertIsInstance(recvd, capnp._DynamicStructReader)
+    # https://github.com/python/mypy/issues/13038
+    assert_carstate(msg.carState, recvd.carState)  # type: ignore[union-attr]
+
+  def test_recv_one(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=1000)
+    zmq_sleep()
+
+    # no msg in queue, socket should timeout
+    recvd = messaging.recv_one(sub_sock)
+    self.assertTrue(recvd is None)
+
+    # one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    recvd = messaging.recv_one(sub_sock)
+    self.assertIsInstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)  # type: ignore[union-attr]
+
+  @zmq_expected_failure
+  def test_recv_one_or_none(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock)
+    zmq_sleep()
+
+    # no msg in queue, socket shouldn't block
+    recvd = messaging.recv_one_or_none(sub_sock)
+    self.assertTrue(recvd is None)
+
+    # one msg in queue
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    recvd = messaging.recv_one_or_none(sub_sock)
+    self.assertIsInstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)  # type: ignore[union-attr]
+
+  def test_recv_one_retry(self):
+    sock = "carState"
+    sock_timeout = 0.1
+    pub_sock = messaging.pub_sock(sock)
+    sub_sock = messaging.sub_sock(sock, timeout=round(sock_timeout*1000))
+    zmq_sleep()
+
+    # this test doesn't work with ZMQ since multiprocessing interrupts it
+    if "ZMQ" not in os.environ:
+      # wait 15 socket timeouts and make sure it's still retrying
+      p = multiprocessing.Process(target=messaging.recv_one_retry, args=(sub_sock,))
+      p.start()
+      time.sleep(sock_timeout*15)
+      self.assertTrue(p.is_alive())
+      p.terminate()
+
+    # wait 15 socket timeouts before sending
+    msg = random_carstate()
+    delayed_send(sock_timeout*15, pub_sock, msg.to_bytes())
+    start_time = time.monotonic()
+    recvd = messaging.recv_one_retry(sub_sock)
+    self.assertGreaterEqual(time.monotonic() - start_time, sock_timeout*15)
+    self.assertIsInstance(recvd, capnp._DynamicStructReader)
+    assert_carstate(msg.carState, recvd.carState)
+
+if __name__ == "__main__":
+  unittest.main()

cereal/messaging/tests/test_poller.py

@@ -0,0 +1,142 @@
+import unittest
+import time
+import cereal.messaging as messaging
+
+import concurrent.futures
+
+
+def poller():
+  context = messaging.Context()
+
+  p = messaging.Poller()
+
+  sub = messaging.SubSocket()
+  sub.connect(context, 'controlsState')
+  p.registerSocket(sub)
+
+  socks = p.poll(10000)
+  r = [s.receive(non_blocking=True) for s in socks]
+
+  return r
+
+
+class TestPoller(unittest.TestCase):
+  def test_poll_once(self):
+    context = messaging.Context()
+
+    pub = messaging.PubSocket()
+    pub.connect(context, 'controlsState')
+
+    with concurrent.futures.ThreadPoolExecutor() as e:
+      poll = e.submit(poller)
+
+      time.sleep(0.1)  # Slow joiner syndrome
+
+      # Send message
+      pub.send(b"a")
+
+      # Wait for poll result
+      result = poll.result()
+
+    del pub
+    context.term()
+
+    self.assertEqual(result, [b"a"])
+
+  def test_poll_and_create_many_subscribers(self):
+    context = messaging.Context()
+
+    pub = messaging.PubSocket()
+    pub.connect(context, 'controlsState')
+
+    with concurrent.futures.ThreadPoolExecutor() as e:
+      poll = e.submit(poller)
+
+      time.sleep(0.1)  # Slow joiner syndrome
+      c = messaging.Context()
+      for _ in range(10):
+        messaging.SubSocket().connect(c, 'controlsState')
+
+      time.sleep(0.1)
+
+      # Send message
+      pub.send(b"a")
+
+      # Wait for poll result
+      result = poll.result()
+
+    del pub
+    context.term()
+
+    self.assertEqual(result, [b"a"])
+
+  def test_multiple_publishers_exception(self):
+    context = messaging.Context()
+
+    with self.assertRaises(messaging.MultiplePublishersError):
+      pub1 = messaging.PubSocket()
+      pub1.connect(context, 'controlsState')
+
+      pub2 = messaging.PubSocket()
+      pub2.connect(context, 'controlsState')
+
+      pub1.send(b"a")
+
+    del pub1
+    del pub2
+    context.term()
+
+  def test_multiple_messages(self):
+    context = messaging.Context()
+
+    pub = messaging.PubSocket()
+    pub.connect(context, 'controlsState')
+
+    sub = messaging.SubSocket()
+    sub.connect(context, 'controlsState')
+
+    time.sleep(0.1)  # Slow joiner
+
+    for i in range(1, 100):
+      pub.send(b'a'*i)
+
+    msg_seen = False
+    i = 1
+    while True:
+      r = sub.receive(non_blocking=True)
+
+      if r is not None:
+        self.assertEqual(b'a'*i, r)
+
+        msg_seen = True
+        i += 1
+
+      if r is None and msg_seen:  # ZMQ sometimes receives nothing on the first receive
+        break
+
+    del pub
+    del sub
+    context.term()
+
+  def test_conflate(self):
+    context = messaging.Context()
+
+    pub = messaging.PubSocket()
+    pub.connect(context, 'controlsState')
+
+    sub = messaging.SubSocket()
+    sub.connect(context, 'controlsState', conflate=True)
+
+    time.sleep(0.1)  # Slow joiner
+    pub.send(b'a')
+    pub.send(b'b')
+
+    self.assertEqual(b'b', sub.receive())
+
+    del pub
+    del sub
+    context.term()
+
+
+if __name__ == "__main__":
+  unittest.main()

cereal/messaging/tests/test_pub_sub_master.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+import random
+import time
+from typing import Sized, cast
+import unittest
+
+import cereal.messaging as messaging
+from cereal.messaging.tests.test_messaging import events, random_sock, random_socks, \
+                                                  random_bytes, random_carstate, assert_carstate, \
+                                                  zmq_sleep
+
+
+class TestSubMaster(unittest.TestCase):
+
+  def setUp(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep(3)
+
+  def test_init(self):
+    sm = messaging.SubMaster(events)
+    for p in [sm.updated, sm.recv_time, sm.recv_frame, sm.alive,
+              sm.sock, sm.data, sm.logMonoTime, sm.valid]:
+      self.assertEqual(len(cast(Sized, p)), len(events))
+
+  def test_init_state(self):
+    socks = random_socks()
+    sm = messaging.SubMaster(socks)
+    self.assertEqual(sm.frame, -1)
+    self.assertFalse(any(sm.updated.values()))
+    self.assertFalse(any(sm.alive.values()))
+    self.assertTrue(all(t == 0. for t in sm.recv_time.values()))
+    self.assertTrue(all(f == 0 for f in sm.recv_frame.values()))
+    self.assertTrue(all(t == 0 for t in sm.logMonoTime.values()))
+
+    for p in [sm.updated, sm.recv_time, sm.recv_frame, sm.alive,
+              sm.sock, sm.data, sm.logMonoTime, sm.valid]:
+      self.assertEqual(len(cast(Sized, p)), len(socks))
+
+  def test_getitem(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+    zmq_sleep()
+
+    msg = random_carstate()
+    pub_sock.send(msg.to_bytes())
+    sm.update(1000)
+    assert_carstate(msg.carState, sm[sock])
+
+  # TODO: break this test up to individually test SubMaster.update and SubMaster.update_msgs
+  def test_update(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+    zmq_sleep()
+
+    for i in range(10):
+      msg = messaging.new_message(sock)
+      pub_sock.send(msg.to_bytes())
+      sm.update(1000)
+      self.assertEqual(sm.frame, i)
+      self.assertTrue(all(sm.updated.values()))
+
+  def test_update_timeout(self):
+    sock = random_sock()
+    sm = messaging.SubMaster([sock,])
+    for _ in range(5):
+      timeout = random.randrange(1000, 5000)
+      start_time = time.monotonic()
+      sm.update(timeout)
+      t = time.monotonic() - start_time
+      self.assertGreaterEqual(t, timeout/1000.)
+      self.assertLess(t, 5)
+      self.assertFalse(any(sm.updated.values()))
+
+  def test_avg_frequency_checks(self):
+    for poll in (True, False):
+      sm = messaging.SubMaster(["modelV2", "carParams", "carState", "cameraOdometry", "liveCalibration"],
+                               poll=("modelV2" if poll else None),
+                               frequency=(20. if not poll else None))
+
+      checks = {
+        "carState": (20, 20),
+        "modelV2": (20, 20 if poll else 10),
+        "cameraOdometry": (20, 10),
+        "liveCalibration": (4, 4),
+        "carParams": (None, None),
+      }
+
+      for service, (max_freq, min_freq) in checks.items():
+        if max_freq is not None:
+          assert sm._check_avg_freq(service)
+          assert sm.max_freq[service] == max_freq*1.2
+          assert sm.min_freq[service] == min_freq*0.8
+        else:
+          assert not sm._check_avg_freq(service)
+
+  def test_alive(self):
+    pass
+
+  def test_ignore_alive(self):
+    pass
+
+  def test_valid(self):
+    pass
+
+  # SubMaster should always conflate
+  def test_conflate(self):
+    sock = "carState"
+    pub_sock = messaging.pub_sock(sock)
+    sm = messaging.SubMaster([sock,])
+
+    n = 10
+    for i in range(n+1):
+      msg = messaging.new_message(sock)
+      msg.carState.vEgo = i
+      pub_sock.send(msg.to_bytes())
+      time.sleep(0.01)
+    sm.update(1000)
+    self.assertEqual(sm[sock].vEgo, n)
+
+
+class TestPubMaster(unittest.TestCase):
+
+  def setUp(self):
+    # ZMQ pub socket takes too long to die
+    # sleep to prevent multiple publishers error between tests
+    zmq_sleep(3)
+
+  def test_init(self):
+    messaging.PubMaster(events)
+
+  def test_send(self):
+    socks = random_socks()
+    pm = messaging.PubMaster(socks)
+    sub_socks = {s: messaging.sub_sock(s, conflate=True, timeout=1000) for s in socks}
+    zmq_sleep()
+
+    # PubMaster accepts either a capnp msg builder or bytes
+    for capnp in [True, False]:
+      for i in range(100):
+        sock = socks[i % len(socks)]
+
+        if capnp:
+          try:
+            msg = messaging.new_message(sock)
+          except Exception:
+            msg = messaging.new_message(sock, random.randrange(50))
+        else:
+          msg = random_bytes()
+
+        pm.send(sock, msg)
+        recvd = sub_socks[sock].receive()
+
+        if capnp:
+          msg.clear_write_flag()
+          msg = msg.to_bytes()
+        self.assertEqual(msg, recvd, i)
+
+
+if __name__ == "__main__":
+  unittest.main()

cereal/messaging/tests/test_services.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+import os
+import tempfile
+from typing import Dict
+import unittest
+from parameterized import parameterized
+
+import cereal.services as services
+from cereal.services import SERVICE_LIST, RESERVED_PORT, STARTING_PORT
+
+
+class TestServices(unittest.TestCase):
+
+  @parameterized.expand(SERVICE_LIST.keys())
+  def test_services(self, s):
+    service = SERVICE_LIST[s]
+    self.assertTrue(service.port != RESERVED_PORT)
+    self.assertTrue(service.port >= STARTING_PORT)
+    self.assertTrue(service.frequency <= 104)
+
+  def test_no_duplicate_port(self):
+    ports: Dict[int, str] = {}
+    for name, service in SERVICE_LIST.items():
+      self.assertFalse(service.port in ports.keys(), f"duplicate port {service.port}")
+      ports[service.port] = name
+
+  def test_generated_header(self):
+    with tempfile.NamedTemporaryFile(suffix=".h") as f:
+      ret = os.system(f"python3 {services.__file__} > {f.name} && clang++ {f.name}")
+      self.assertEqual(ret, 0, "generated services header is not valid C")
+
+if __name__ == "__main__":
+  unittest.main()