diff --git a/python/pacemaker/_cts/tests/nearquorumpointtest.py b/python/pacemaker/_cts/tests/nearquorumpointtest.py
index 282260a04c..316e55ba63 100644
--- a/python/pacemaker/_cts/tests/nearquorumpointtest.py
+++ b/python/pacemaker/_cts/tests/nearquorumpointtest.py
@@ -1,118 +1,118 @@
-""" Test-specific classes for Pacemaker's Cluster Test Suite (CTS)
-"""
+""" Randomly start and stop nodes to bring the cluster close to the quorum point """
 
 __all__ = ["NearQuorumPointTest"]
 __copyright__ = "Copyright 2000-2023 the Pacemaker project contributors"
 __license__ = "GNU General Public License version 2 or later (GPLv2+) WITHOUT ANY WARRANTY"
 
 from pacemaker._cts.tests.ctstest import CTSTest
 
 
 class NearQuorumPointTest(CTSTest):
-    '''
-    This test brings larger clusters near the quorum point (50%).
-    In addition, it will test doing starts and stops at the same time.
-
-    Here is how I think it should work:
-    - loop over the nodes and decide randomly which will be up and which
-      will be down  Use a 50% probability for each of up/down.
-    - figure out what to do to get into that state from the current state
-    - in parallel, bring up those going up  and bring those going down.
-    '''
+    """ A concrete test that randomly starts and stops nodes to bring the
+        cluster close to the quorum point
+    """
 
     def __init__(self, cm):
-        CTSTest.__init__(self,cm)
+        """ Create a new NearQuorumPointTest instance
+
+            Arguments:
+
+            cm -- A ClusterManager instance
+        """
+
+        CTSTest.__init__(self, cm)
+
         self.name = "NearQuorumPoint"
 
     def __call__(self, dummy):
-        '''Perform the 'NearQuorumPoint' test. '''
+        """ Perform this test """
+
         self.incr("calls")
         startset = []
         stopset = []
 
         stonith = self._cm.prepare_fencing_watcher("NearQuorumPoint")
         #decide what to do with each node
         for node in self._env["nodes"]:
-            action = self._env.random_gen.choice(["start","stop"])
-            #action = self._env.random_gen.choice(["start","stop","no change"])
+            action = self._env.random_gen.choice(["start", "stop"])
+
             if action == "start" :
                 startset.append(node)
             elif action == "stop" :
                 stopset.append(node)
 
         self.debug("start nodes:" + repr(startset))
         self.debug("stop nodes:" + repr(stopset))
 
         #add search patterns
         watchpats = [ ]
         for node in stopset:
             if self._cm.ShouldBeStatus[node] == "up":
                 watchpats.append(self.templates["Pat:We_stopped"] % node)
 
         for node in startset:
             if self._cm.ShouldBeStatus[node] == "down":
-                #watchpats.append(self.templates["Pat:NonDC_started"] % node)
                 watchpats.append(self.templates["Pat:Local_started"] % node)
             else:
                 for stopping in stopset:
                     if self._cm.ShouldBeStatus[stopping] == "up":
                         watchpats.append(self.templates["Pat:They_stopped"] % (node, self._cm.key_for_node(stopping)))
 
         if len(watchpats) == 0:
             return self.skipped()
 
         if len(startset) != 0:
             watchpats.append(self.templates["Pat:DC_IDLE"])
 
         watch = self.create_watch(watchpats, self._env["DeadTime"]+10)
 
         watch.set_watch()
 
         #begin actions
         for node in stopset:
             if self._cm.ShouldBeStatus[node] == "up":
                 self._cm.StopaCMnoBlock(node)
 
         for node in startset:
             if self._cm.ShouldBeStatus[node] == "down":
                 self._cm.StartaCMnoBlock(node)
 
         #get the result
         if watch.look_for_all():
             self._cm.cluster_stable()
             self._cm.fencing_cleanup("NearQuorumPoint", stonith)
             return self.success()
 
         self._logger.log("Warn: Patterns not found: " + repr(watch.unmatched))
 
         #get the "bad" nodes
         upnodes = []
         for node in stopset:
             if self._cm.StataCM(node) == 1:
                 upnodes.append(node)
 
         downnodes = []
         for node in startset:
             if self._cm.StataCM(node) == 0:
                 downnodes.append(node)
 
         self._cm.fencing_cleanup("NearQuorumPoint", stonith)
         if upnodes == [] and downnodes == []:
             self._cm.cluster_stable()
 
             # Make sure they're completely down with no residule
             for node in stopset:
                 self._rsh(node, self.templates["StopCmd"])
 
             return self.success()
 
         if len(upnodes) > 0:
             self._logger.log("Warn: Unstoppable nodes: " + repr(upnodes))
 
         if len(downnodes) > 0:
             self._logger.log("Warn: Unstartable nodes: " + repr(downnodes))
 
         return self.failure()
 
     def is_applicable(self):
         return True