diff --git a/tests/test_before.py b/tests/test_before.py
new file mode 100644
index 00000000..83e86fe9
--- /dev/null
+++ b/tests/test_before.py
@@ -0,0 +1,11 @@
+import unittest
+
+from tenacity import before_nothing
+
+from . import test_tenacity
+
+
+class TestBeforeNothing(unittest.TestCase):
+    def test_before_nothing_does_not_raise(self) -> None:
+        retry_state = test_tenacity.make_retry_state(1, 0.1)
+        before_nothing(retry_state)
diff --git a/tests/test_before_sleep.py b/tests/test_before_sleep.py
new file mode 100644
index 00000000..e569514d
--- /dev/null
+++ b/tests/test_before_sleep.py
@@ -0,0 +1,11 @@
+import unittest
+
+from tenacity import before_sleep_nothing
+
+from . import test_tenacity
+
+
+class TestBeforeSleepNothing(unittest.TestCase):
+    def test_before_sleep_nothing_does_not_raise(self) -> None:
+        retry_state = test_tenacity.make_retry_state(1, 0.1)
+        before_sleep_nothing(retry_state)
diff --git a/tests/test_nap.py b/tests/test_nap.py
new file mode 100644
index 00000000..201a2e29
--- /dev/null
+++ b/tests/test_nap.py
@@ -0,0 +1,40 @@
+import threading
+import unittest
+import unittest.mock
+
+from tenacity import nap
+
+
+class TestSleep(unittest.TestCase):
+    def test_sleep_delegates_to_time_sleep(self) -> None:
+        with unittest.mock.patch("tenacity.nap.time.sleep") as mock_sleep:
+            nap.sleep(1.5)
+        mock_sleep.assert_called_once_with(1.5)
+
+
+class TestSleepUsingEvent(unittest.TestCase):
+    def test_waits_on_event_with_given_timeout(self) -> None:
+        event = unittest.mock.MagicMock(spec=threading.Event)
+        strategy = nap.sleep_using_event(event)
+
+        strategy(5)
+
+        event.wait.assert_called_once_with(timeout=5)
+
+    def test_waits_on_event_with_none_timeout(self) -> None:
+        event = unittest.mock.MagicMock(spec=threading.Event)
+        strategy = nap.sleep_using_event(event)
+
+        strategy(None)
+
+        event.wait.assert_called_once_with(timeout=None)
+
+    def test_returns_early_when_event_already_set(self) -> None:
+        # threading.Event.wait() returns immediately (without blocking for
+        # the timeout) when the event is already set, so a large timeout
+        # here is safe and still exercises the real stdlib primitive.
+        event = threading.Event()
+        event.set()
+        strategy = nap.sleep_using_event(event)
+
+        strategy(60)