cocotb 2.0.0b1__cp311-cp311-macosx_10_9_x86_64.whl → 2.0.0rc2__cp311-cp311-macosx_10_9_x86_64.whl

cocotb/_ANSI.py

@@ -4,69 +4,62 @@
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
 
-"""
-Some constants for doing ANSI stuff.
-"""
+from cocotb._py_compat import StrEnum
 
-# flake8: noqa (skip this file for flake8: pypi.python.org/pypi/flake8)
 _ESCAPE = "\033["
 
-# see https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
 
-DEFAULT_FG = _ESCAPE + "39m"
-DEFAULT_BG = _ESCAPE + "49m"
-DEFAULT = DEFAULT_BG + DEFAULT_FG
+class ANSI(StrEnum):
+    """ANSI escape codes for coloring output.
 
-BLACK_FG = _ESCAPE + "30m"
-RED_FG = _ESCAPE + "31m"
-GREEN_FG = _ESCAPE + "32m"
-YELLOW_FG = _ESCAPE + "33m"
-BLUE_FG = _ESCAPE + "34m"
-MAGENTA_FG = _ESCAPE + "35m"
-CYAN_FG = _ESCAPE + "36m"
-WHITE_FG = _ESCAPE + "37m"
+    The color names supported are ``[BRIGHT_]{BLACK|RED|GREEN|YELLOW|BLUE|MAGENTA|CYAN|WHITE}{_FG|_BG}``.
 
-BLACK_BG = _ESCAPE + "40m"
-RED_BG = _ESCAPE + "41m"
-GREEN_BG = _ESCAPE + "42m"
-YELLOW_BG = _ESCAPE + "43m"
-BLUE_BG = _ESCAPE + "44m"
-MAGENTA_BG = _ESCAPE + "45m"
-CYAN_BG = _ESCAPE + "46m"
-WHITE_BG = _ESCAPE + "47m"
+    Variables that end in ``_FG`` will color the character or symbol ("foreground")
+    and variables that end in ``_BG`` will color the background.
 
-BRIGHT_BLACK_FG = _ESCAPE + "90m"
-BRIGHT_RED_FG = _ESCAPE + "91m"
-BRIGHT_GREEN_FG = _ESCAPE + "92m"
-BRIGHT_YELLOW_FG = _ESCAPE + "93m"
-BRIGHT_BLUE_FG = _ESCAPE + "94m"
-BRIGHT_MAGENTA_FG = _ESCAPE + "95m"
-BRIGHT_CYAN_FG = _ESCAPE + "96m"
-BRIGHT_WHITE_FG = _ESCAPE + "97m"
+    Foreground and background colors can be combined together with a ``+``.
+    Setting a new foreground color will override the previous foreground, likewise with background colors.
 
-BRIGHT_BLACK_BG = _ESCAPE + "100m"
-BRIGHT_RED_BG = _ESCAPE + "101m"
-BRIGHT_GREEN_BG = _ESCAPE + "102m"
-BRIGHT_YELLOW_BG = _ESCAPE + "103m"
-BRIGHT_BLUE_BG = _ESCAPE + "104m"
-BRIGHT_MAGENTA_BG = _ESCAPE + "105m"
-BRIGHT_CYAN_BG = _ESCAPE + "106m"
-BRIGHT_WHITE_BG = _ESCAPE + "107m"
+    Use ``DEFAULT_FG`` and ``DEFAULT_BG`` to reset the coloring to the default colors for the foreground and background, respectively.
+    Or use ``DEFAULT`` to reset both.
+    """
 
+    DEFAULT_FG = _ESCAPE + "39m"
+    DEFAULT_BG = _ESCAPE + "49m"
+    DEFAULT = DEFAULT_BG + DEFAULT_FG
 
-COLOR_DEFAULT = DEFAULT
+    BLACK_FG = _ESCAPE + "30m"
+    RED_FG = _ESCAPE + "31m"
+    GREEN_FG = _ESCAPE + "32m"
+    YELLOW_FG = _ESCAPE + "33m"
+    BLUE_FG = _ESCAPE + "34m"
+    MAGENTA_FG = _ESCAPE + "35m"
+    CYAN_FG = _ESCAPE + "36m"
+    WHITE_FG = _ESCAPE + "37m"
 
-COLOR_WARNING = YELLOW_FG
-COLOR_ERROR = RED_FG
-COLOR_CRITICAL = RED_BG + BLACK_FG
-COLOR_TEST = BLUE_FG
-COLOR_PASSED = GREEN_FG
-COLOR_SKIPPED = YELLOW_FG
-COLOR_FAILED = RED_FG
+    BLACK_BG = _ESCAPE + "40m"
+    RED_BG = _ESCAPE + "41m"
+    GREEN_BG = _ESCAPE + "42m"
+    YELLOW_BG = _ESCAPE + "43m"
+    BLUE_BG = _ESCAPE + "44m"
+    MAGENTA_BG = _ESCAPE + "45m"
+    CYAN_BG = _ESCAPE + "46m"
+    WHITE_BG = _ESCAPE + "47m"
 
-COLOR_HILITE_SUMMARY = WHITE_FG + RED_BG
-COLOR_HILITE_HEXDIFF_DEFAULT = YELLOW_FG
-COLOR_HILITE_HEXDIFF_1 = CYAN_FG
-COLOR_HILITE_HEXDIFF_2 = RED_FG
-COLOR_HILITE_HEXDIFF_3 = MAGENTA_BG
-COLOR_HILITE_HEXDIFF_4 = CYAN_BG + BLACK_FG
+    BRIGHT_BLACK_FG = _ESCAPE + "90m"
+    BRIGHT_RED_FG = _ESCAPE + "91m"
+    BRIGHT_GREEN_FG = _ESCAPE + "92m"
+    BRIGHT_YELLOW_FG = _ESCAPE + "93m"
+    BRIGHT_BLUE_FG = _ESCAPE + "94m"
+    BRIGHT_MAGENTA_FG = _ESCAPE + "95m"
+    BRIGHT_CYAN_FG = _ESCAPE + "96m"
+    BRIGHT_WHITE_FG = _ESCAPE + "97m"
+
+    BRIGHT_BLACK_BG = _ESCAPE + "100m"
+    BRIGHT_RED_BG = _ESCAPE + "101m"
+    BRIGHT_GREEN_BG = _ESCAPE + "102m"
+    BRIGHT_YELLOW_BG = _ESCAPE + "103m"
+    BRIGHT_BLUE_BG = _ESCAPE + "104m"
+    BRIGHT_MAGENTA_BG = _ESCAPE + "105m"
+    BRIGHT_CYAN_BG = _ESCAPE + "106m"
+    BRIGHT_WHITE_BG = _ESCAPE + "107m"

cocotb/__init__.py

@@ -3,6 +3,7 @@
 # Copyright (c) 2013 SolarFlare Communications Inc
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
+import sys
 from typing import TYPE_CHECKING, Dict, List, Union
 
 from cocotb._decorators import (
@@ -50,7 +51,7 @@ parametrize.__module__ = __name__
 pass_test.__module__ = __name__
 
 
-__version__ = _version
+__version__: str = _version
 """The version of cocotb."""
 
 
@@ -76,7 +77,7 @@ argv: List[str]
 plusargs: Dict[str, Union[bool, str]]
 """A dictionary of "plusargs" handed to the simulation.
 
-See :make:var:`COCOTB_PLUSARGS` for details.
+See :envvar:`COCOTB_PLUSARGS` for details.
 """
 
 packages: "SimpleNamespace"
@@ -113,3 +114,12 @@ and in parameters to :class:`.TestFactory`\ s.
 
 is_simulation: bool = False
 """``True`` if cocotb was loaded in a simulation."""
+
+
+if sys.version_info < (3, 8):
+    import warnings
+
+    warnings.warn(
+        "Support for Python versions < 3.8 will be dropped in version 2.1",
+        FutureWarning,
+    )

cocotb/_base_triggers.py

@@ -442,17 +442,18 @@ class NullTrigger(Trigger):
     **Do not** do this:
 
     .. code-block:: python
+        :class: removed
 
         transaction_data = None
 
 
-        def monitor():
+        def monitor(dut):
             while dut.valid.value != 1 and dut.ready.value != 1:
                 await RisingEdge(dut.clk)
             transaction_data = dut.data.value
 
 
-        def use_transaction():
+        def use_transaction(dut):
             while True:
                 await RisingEdge(dut.clk)
                 # We need the NullTrigger here because both Tasks react to RisingEdge,
@@ -463,33 +464,34 @@ class NullTrigger(Trigger):
                     process(transaction_data)
 
 
-        use_task = cocotb.start_soon(use_transaction())
-        monitor_task = cocotb.start_soon(monitor())
+        use_task = cocotb.start_soon(use_transaction(cocotb.top))
+        monitor_task = cocotb.start_soon(monitor(cocotb.top))
 
-    Instead use an :class:`!.Event` to explicitly synchronize the two Tasks, like so:
+    Instead use an :class:`!Event` to explicitly synchronize the two Tasks, like so:
 
     .. code-block:: python
+        :class: new
 
         transaction_data = None
         transaction_event = Event()
 
 
-        def monitor():
+        def monitor(dut):
             while dut.valid.value != 1 and dut.ready.value != 1:
                 await RisingEdge(dut.clk)
             transaction_data = dut.data.value
             transaction_event.set()
 
 
-        def use_transaction():
+        def use_transaction(dut):
             # Now we don't need the NullTrigger.
             # This Task will wake up *strictly* after `monitor_task` sets the transaction.
             await transaction_event.wait()
             process(transaction_data)
 
 
-        use_task = cocotb.start_soon(use_transaction())
-        monitor_task = cocotb.start_soon(monitor())
+        use_task = cocotb.start_soon(use_transaction(cocotb.top))
+        monitor_task = cocotb.start_soon(monitor(cocotb.top))
 
     .. versionremoved:: 2.0
         The *outcome* parameter was removed. There is no alternative.

cocotb/_bridge.py

@@ -3,10 +3,10 @@
 # SPDX-License-Identifier: BSD-3-Clause
 import functools
 import logging
-import os
 import threading
 from enum import IntEnum
 from typing import (
+    TYPE_CHECKING,
     Callable,
     Coroutine,
     Generic,
@@ -15,14 +15,13 @@ from typing import (
 )
 
 import cocotb
+from cocotb import debug
 from cocotb._base_triggers import Event, Trigger
 from cocotb._exceptions import InternalError
-from cocotb._outcomes import Outcome
 from cocotb._py_compat import ParamSpec
 
-# Sadly the Python standard logging module is very slow so it's better not to
-# make any calls by testing a boolean flag first
-_debug = "COCOTB_SCHEDULER_DEBUG" in os.environ
+if TYPE_CHECKING:
+    from cocotb._outcomes import Outcome
 
 P = ParamSpec("P")
 
@@ -133,7 +132,7 @@ class external_waiter(Generic[Result]):
 
     def _propagate_state(self, new_state: external_state) -> None:
         with self.cond:
-            if _debug:
+            if debug.debug:
                 self._log.debug(
                     f"Changing state from {self.state} -> {new_state} from {threading.current_thread()}"
                 )
@@ -141,7 +140,7 @@ class external_waiter(Generic[Result]):
             self.cond.notify()
 
     def thread_done(self) -> None:
-        if _debug:
+        if debug.debug:
             self._log.debug(f"Thread finished from {threading.current_thread()}")
         self._propagate_state(external_state.EXITED)
 
@@ -160,7 +159,7 @@ class external_waiter(Generic[Result]):
         self._propagate_state(external_state.RUNNING)
 
     def thread_wait(self) -> external_state:
-        if _debug:
+        if debug.debug:
             self._log.debug(
                 f"Waiting for the condition lock {threading.current_thread()}"
             )
@@ -169,7 +168,7 @@ class external_waiter(Generic[Result]):
             while self.state == external_state.RUNNING:
                 self.cond.wait()
 
-            if _debug:
+            if debug.debug:
                 if self.state == external_state.EXITED:
                     self._log.debug(
                         f"Thread {self.thread} has exited from {threading.current_thread()}"

cocotb/_extended_awaitables.py

@@ -206,7 +206,7 @@ class First(_AggregateWaitable[object]):
 class ClockCycles(Waitable["ClockCycles"]):
     r"""Finishes after *num_cycles* transitions of *signal*.
 
-    :keyword:`await`\ ing this Trigger returns the ClockCycle object.
+    :keyword:`await`\ ing this Trigger returns the :class:`!ClockCycles` object.
 
     Args:
         signal: The signal to monitor.

cocotb/_gpi_triggers.py

@@ -10,6 +10,7 @@ import warnings
 from decimal import Decimal
 from fractions import Fraction
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     ClassVar,
@@ -24,11 +25,13 @@ import cocotb.handle
 from cocotb import simulator
 from cocotb._base_triggers import Trigger
 from cocotb._deprecation import deprecated
-from cocotb._py_compat import Self
 from cocotb._typing import RoundMode, TimeUnit
 from cocotb._utils import pointer_str, singleton
 from cocotb.utils import get_sim_steps, get_time_from_sim_steps
 
+if TYPE_CHECKING:
+    from cocotb._py_compat import Self
+
 
 class GPITrigger(Trigger):
     """A trigger for a simulation event."""

cocotb/_init.py

@@ -17,6 +17,8 @@ from typing import Callable, List, cast
 import cocotb
 import cocotb._profiling
 import cocotb.handle
+import cocotb.logging
+import cocotb.simtime
 import cocotb.simulator
 from cocotb._scheduler import Scheduler
 from cocotb.regression import RegressionManager, RegressionMode
@@ -62,6 +64,7 @@ def init_package_from_simulation(argv: List[str]) -> None:
     # Add it back because users expect to be able to import files in their test directory.
     sys.path.insert(0, "")
 
+    cocotb.logging._init()
     _setup_logging()
 
     # From https://www.python.org/dev/peps/pep-0565/#recommended-filter-settings-for-test-runners
@@ -84,6 +87,8 @@ def init_package_from_simulation(argv: List[str]) -> None:
     _setup_root_handle()
     _start_user_coverage()
 
+    cocotb.simtime._init()
+
     log.info(
         "Initialized cocotb v%s from %s",
         cocotb.__version__,
@@ -171,19 +176,11 @@ def _start_user_coverage() -> None:
                 "Coverage collection requested but coverage module not available. Install it using `pip install coverage`."
             ) from None
         else:
-            config_filepath = os.getenv("COCOTB_COVERAGE_RCFILE")
-            if config_filepath is None:
-                config_filepath = os.getenv("COVERAGE_RCFILE")
-                if config_filepath is not None:
-                    warnings.warn(
-                        "COVERAGE_RCFILE is deprecated in favor of COCOTB_COVERAGE_RCFILE",
-                        DeprecationWarning,
-                        stacklevel=2,
-                    )
+            config_filepath = os.getenv("COVERAGE_RCFILE")
             if config_filepath is None:
                 # Exclude cocotb itself from coverage collection.
                 log.info(
-                    "Collecting coverage of user code. No coverage config file supplied via COCOTB_COVERAGE_RCFILE."
+                    "Collecting coverage of user code. No coverage config file supplied via COVERAGE_RCFILE."
                 )
                 cocotb_package_dir = Path(__file__).parent.absolute()
                 user_coverage = coverage.coverage(
@@ -213,10 +210,14 @@ def _setup_random_seed() -> None:
             warnings.warn(
                 "RANDOM_SEED is deprecated in favor of COCOTB_RANDOM_SEED",
                 DeprecationWarning,
-                stacklevel=2,
             )
     if seed_envvar is None:
         if "ntb_random_seed" in cocotb.plusargs:
+            warnings.warn(
+                "Passing +ntb_random_seed will not be used to seed Python's random number generator in the future. "
+                "Ensure you also set `COCOTB_RANDOM_SEED`.",
+                FutureWarning,
+            )
             plusarg_seed = cocotb.plusargs["ntb_random_seed"]
             if not isinstance(plusarg_seed, str):
                 raise TypeError("ntb_random_seed plusarg is not a valid seed value.")
@@ -225,6 +226,11 @@ def _setup_random_seed() -> None:
                 raise TypeError("ntb_random_seed plusargs is not a valid seed value.")
             cocotb.RANDOM_SEED = seed
         elif "seed" in cocotb.plusargs:
+            warnings.warn(
+                "Passing +seed will not be used to seed Python's random number generator in the future. "
+                "Ensure you also set `COCOTB_RANDOM_SEED`.",
+                FutureWarning,
+            )
             plusarg_seed = cocotb.plusargs["seed"]
             if not isinstance(plusarg_seed, str):
                 raise TypeError("seed plusarg is not a valid seed value.")

cocotb/_py_compat.py

@@ -20,6 +20,7 @@ __all__ = (
     "ParamSpec",
     "Protocol",
     "Self",
+    "StrEnum",
     "TypeAlias",
     "cached_property",
     "insertion_ordered_dict",
@@ -98,14 +99,15 @@ else:
             return res
 
 
-class FakeGetItemType:
-    def __class_getitem__(self, a: object) -> str:
-        return ""
-
-
 if sys.version_info >= (3, 8):
     from typing import Final, Literal, Protocol
 else:
+    from typing import Any
+
+    class FakeGetItemType:
+        def __class_getitem__(self, a: object) -> Any:
+            return Any
+
     Final = FakeGetItemType
     Literal = FakeGetItemType
     Protocol = ABC
@@ -114,16 +116,18 @@ else:
 if sys.version_info >= (3, 10):
     from typing import ParamSpec, TypeAlias
 else:
-    TypeAlias = ""
+    from typing import Any
+
+    TypeAlias = Any
 
     class FakeParamSpecType:
         def __init__(self, name: str) -> None: ...
 
-        def kwargs(self) -> str:
-            return ""
+        def kwargs(self) -> Any:
+            return Any
 
-        def args(self) -> str:
-            return ""
+        def args(self) -> Any:
+            return Any
 
     ParamSpec = FakeParamSpecType
 
@@ -132,3 +136,13 @@ if sys.version_info >= (3, 11):
     from typing import Self
 else:
     Self = ""
+
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        def __str__(self) -> str:
+            return self.value

cocotb/_scheduler.py

@@ -1,20 +1,12 @@
-#!/usr/bin/env python
-
 # Copyright cocotb contributors
 # Copyright (c) 2013, 2018 Potential Ventures Ltd
 # Copyright (c) 2013 SolarFlare Communications Inc
 # Licensed under the Revised BSD License, see LICENSE for details.
 # SPDX-License-Identifier: BSD-3-Clause
 
-"""Task scheduler.
-
-FIXME: We have a problem here. If a task schedules a read-only but we
-also have pending writes we have to schedule the ReadWrite callback before
-the ReadOnly (and this is invalid, at least in Modelsim).
-"""
+"""Task scheduler."""
 
 import logging
-import os
 import threading
 from bdb import BdbQuit
 from collections import OrderedDict
@@ -23,6 +15,7 @@ from typing import Any, Callable, Coroutine, Dict, List, TypeVar, Union
 import cocotb
 import cocotb._gpi_triggers
 import cocotb.handle
+from cocotb import debug
 from cocotb._base_triggers import Event, Trigger
 from cocotb._bridge import external_state, external_waiter
 from cocotb._exceptions import InternalError
@@ -36,11 +29,6 @@ from cocotb._profiling import profiling_context
 from cocotb._py_compat import ParamSpec, insertion_ordered_dict
 from cocotb.task import Task, _TaskState
 
-# Sadly the Python standard logging module is very slow so it's better not to
-# make any calls by testing a boolean flag first
-_debug = "COCOTB_SCHEDULER_DEBUG" in os.environ
-
-
 T = TypeVar("T")
 
 P = ParamSpec("P")
@@ -120,8 +108,6 @@ class Scheduler:
 
     def __init__(self) -> None:
         self.log = logging.getLogger("cocotb.scheduler")
-        if _debug:
-            self.log.setLevel(logging.DEBUG)
 
         # A dictionary of pending tasks for each trigger,
         # indexed by trigger
@@ -164,7 +150,7 @@ class Scheduler:
 
         Finds all Tasks waiting on the Trigger that fired and queues them.
         """
-        if _debug:
+        if debug.debug:
             self.log.debug("Trigger fired: %s", trigger)
 
         # find all tasks waiting on trigger that fired
@@ -175,16 +161,19 @@ class Scheduler:
             # associated task waiting on that trigger, otherwise it would
             # have been unprimed already
             if isinstance(trigger, GPITrigger):
-                self.log.critical("No tasks waiting on trigger that fired: %s", trigger)
-                trigger._log.info("I'm the culprit")
+                self.log.warning(
+                    "No tasks waiting on GPITrigger that fired: %s\n"
+                    "This is due to an issue with the GPI or a simulator bug.",
+                    trigger,
+                )
             # For Python triggers this isn't actually an error - we might do
             # event.set() without knowing whether any tasks are actually
             # waiting on this event, for example
-            elif _debug:
+            elif debug.debug:
                 self.log.debug("No tasks waiting on trigger that fired: %s", trigger)
             return
 
-        if _debug:
+        if debug.debug:
             debugstr = "\n\t".join([str(task) for task in scheduling])
             if len(scheduling) > 0:
                 debugstr = "\n\t" + debugstr
@@ -215,10 +204,10 @@ class Scheduler:
         while self._scheduled_tasks:
             task, exc = self._scheduled_tasks.popitem(last=False)
 
-            if _debug:
+            if debug.debug:
                 self.log.debug("Scheduling task %s", task)
             self._resume_task(task, exc)
-            if _debug:
+            if debug.debug:
                 self.log.debug("Scheduled task %s", task)
 
             # remove our reference to the objects at the end of each loop,
@@ -228,14 +217,14 @@ class Scheduler:
 
             # Schedule may have queued up some events so we'll burn through those
             while self._pending_events:
-                if _debug:
+                if debug.debug:
                     self.log.debug(
                         "Scheduling pending event %s", self._pending_events[0]
                     )
                 self._pending_events.pop(0).set()
 
         # no more pending tasks
-        if _debug:
+        if debug.debug:
             self.log.debug("All tasks scheduled, handing control back to simulator")
 
     def _unschedule(self, task: Task[Any]) -> None:
@@ -289,6 +278,10 @@ class Scheduler:
 
         It is an error to attempt to queue a task that has already been queued.
         """
+        if task.done():
+            raise RuntimeError(
+                f"{task} has finished executing and can not be scheduled again. Did you call start_soon() on a finished Task?"
+            )
         if task in self._scheduled_tasks:
             return
         for tasks in self._trigger2tasks.values():
@@ -341,7 +334,8 @@ class Scheduler:
             event.set()
 
         event = threading.Event()
-        self._schedule_task_internal(Task(wrapper()))
+        # must register this with test as there's no way to clean up with threading
+        self._schedule_task_internal(cocotb.start_soon(wrapper()))
         # The scheduler thread blocks in `thread_wait`, and is woken when we
         # call `thread_suspend` - so we need to make sure the task is
         # queued before that.
@@ -367,7 +361,7 @@ class Scheduler:
 
         def execute_external() -> None:
             waiter._outcome = capture(func, *args, **kwargs)
-            if _debug:
+            if debug.debug:
                 self.log.debug(
                     "Execution of external routine done %s", threading.current_thread()
                 )
@@ -410,13 +404,13 @@ class Scheduler:
             trigger = task._advance(exc)
 
             if task.done():
-                if _debug:
+                if debug.debug:
                     self.log.debug("%s completed with %s", task, task._outcome)
                 assert trigger is None
                 self._unschedule(task)
 
             if not task.done():
-                if _debug:
+                if debug.debug:
                     self.log.debug("%r yielded %s", task, trigger)
                 if not isinstance(trigger, Trigger):
                     e = TypeError(
@@ -434,14 +428,14 @@ class Scheduler:
             if self._main_thread is threading.current_thread():
                 for ext in self._pending_threads:
                     ext.thread_start()
-                    if _debug:
+                    if debug.debug:
                         self.log.debug(
                             "Blocking from %s on %s",
                             threading.current_thread(),
                             ext.thread,
                         )
                     state = ext.thread_wait()
-                    if _debug:
+                    if debug.debug:
                         self.log.debug(
                             "Back from wait on self %s with newstate %s",
                             threading.current_thread(),

cocotb/_test.py

@@ -14,12 +14,12 @@ from typing import (
 )
 
 import cocotb
+from cocotb._base_triggers import NullTrigger, Trigger
 from cocotb._deprecation import deprecated
 from cocotb._exceptions import InternalError
 from cocotb._outcomes import Error, Outcome, Value
 from cocotb._test_functions import TestSuccess
 from cocotb.task import ResultType, Task
-from cocotb.triggers import NullTrigger, Trigger
 
 _pdb_on_exception = "COCOTB_PDB_ON_EXCEPTION" in os.environ
 
@@ -89,7 +89,10 @@ class RunningTest:
 
         # Break into pdb on test end before all Tasks are killed.
         if _pdb_on_exception and isinstance(outcome, Error):
-            pdb.post_mortem(outcome.error.__traceback__)
+            try:
+                pdb.post_mortem(outcome.error.__traceback__)
+            except BaseException:
+                pdb.set_trace()
 
         # Set outcome and cancel Tasks.
         self._outcome = outcome
@@ -99,8 +102,8 @@ class RunningTest:
         self._test_complete_cb()
 
     def add_task(self, task: Task[Any]) -> None:
-        task._add_done_callback(self._task_done_callback)
         self.tasks.append(task)
+        task._add_done_callback(self._task_done_callback)
 
     def _task_done_callback(self, task: Task[Any]) -> None:
         self.tasks.remove(task)