// When event fires, try to call another model method that needs the lock
 events.addListener(
     NodeRemovedEvent.listener(
         status -> {
           try {
-            // This needs the read lock - if event is fired inside write lock,
-            // this would work due to lock downgrading, but we verify the pattern
-            model.getSnapshot();
+            // This needs the write lock. If the event is fired inside the
+            // purgeDeadNodes's write lock, this will block and time out.
+            // We use a dummy node ID since we just need to acquire the lock.
+            model.setAvailability(new NodeId(UUID.randomUUID()), UP);
             canAcquireLock.set(true);
           } catch (Exception e) {
             canAcquireLock.set(false);
           }
           eventFired.countDown();
         }));

-removedNodes.forEach(node -> events.fire(new NodeRemovedEvent(node)));
+for (NodeStatus node : removedNodes) {
+  try {
+    events.fire(new NodeRemovedEvent(node));
+  } catch (RuntimeException e) {
+    LOG.warning(String.format(
+      "Error firing NodeRemovedEvent for node %s: %s",
+      node.getNodeId(), e.getMessage()));
+  }
+}

-Set<NodeStatus> removedNodes = new HashSet<>();
+List<NodeStatus> removedNodes = new ArrayList<>();

+AtomicReference<Throwable> threadFailure = new AtomicReference<>();
+
 executor.submit(
     () -> {
       try {
         thread1Started.countDown();
         thread2Started.await(1, TimeUnit.SECONDS);
 
         synchronized (externalLock) {
-          // This simulates LocalNodeRegistry.updateNodeAvailability()
-          // which holds its lock and calls model.setAvailability()
           model.setAvailability(nodeId, UP);
         }
-      } catch (Exception e) {
-        // Ignore interruption
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        threadFailure.compareAndSet(null, e);
+      } catch (Throwable t) {
+        threadFailure.compareAndSet(null, t);
       } finally {
         testComplete.countDown();
       }
     });

-boolean completed = testComplete.await(5, TimeUnit.SECONDS);
-executor.shutdownNow();
+boolean completed;
+try {
+  completed = testComplete.await(5, TimeUnit.SECONDS);
+} finally {
+  executor.shutdownNow();
+  executor.awaitTermination(5, TimeUnit.SECONDS);
+}
 
 if (!completed) {
   deadlockDetected.set(true);
 }