remove some tests

Author: kumaraditya303

Lib/test/test_capi/test_misc.py

@@ -1560,9 +1560,7 @@ def callback():
             #try submitting callback until successful.
             #rely on regular interrupt to flush queue if we are
             #unsuccessful.
-            while True:
-                if _testcapi._pending_threadfunc(callback):
-                    break
+            self.assertTrue(_testcapi._pending_threadfunc(callback))
 
     def pendingcalls_submit(self, l, n, *, main=True):
         def callback():
@@ -1633,51 +1631,11 @@ def test_main_pendingcalls_non_threaded(self):
         #again, just using the main thread, likely they will all be dispatched at
         #once.  It is ok to ask for too many, because we loop until we find a slot.
         #the loop can be interrupted to dispatch.
-        #there are only 32 dispatch slots, so we go for twice that!
         l = []
         n = 64
         self.main_pendingcalls_submit(l, n)
         self.pendingcalls_wait(l, n)
 
-    def test_max_pending(self):
-        with self.subTest('main-only'):
-            maxpending = 32
-
-            l = []
-            added = self.pendingcalls_submit(l, 1, main=True)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, 1)
-
-            l = []
-            added = self.pendingcalls_submit(l, maxpending, main=True)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, maxpending)
-
-            l = []
-            added = self.pendingcalls_submit(l, maxpending+1, main=True)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, maxpending)
-
-        with self.subTest('not main-only'):
-            # Per-interpreter pending calls has a much higher limit
-            # on how many may be pending at a time.
-            maxpending = 300
-
-            l = []
-            added = self.pendingcalls_submit(l, 1, main=False)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, 1)
-
-            l = []
-            added = self.pendingcalls_submit(l, maxpending, main=False)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, maxpending)
-
-            l = []
-            added = self.pendingcalls_submit(l, 1000, main=False)
-            self.pendingcalls_wait(l, added)
-            self.assertEqual(added, maxpending)
-
     class PendingTask(types.SimpleNamespace):
 
         _add_pending = _testinternalcapi.pending_threadfunc
@@ -1711,10 +1669,10 @@ def callback():
                 # the eval breaker, so we take a naive approach to
                 # make sure.
                 if threading.get_ident() not in worker_tids:
-                    self._add_pending(callback, ensure_added=True)
+                    self._add_pending(callback)
                     return
                 self.run()
-            self._add_pending(callback, ensure_added=True)
+            self._add_pending(callback)
 
         def create_thread(self, worker_tids):
             return threading.Thread(

Modules/_testinternalcapi.c

@@ -1072,7 +1072,6 @@ pending_threadfunc(PyObject *self, PyObject *args, PyObject *kwargs)
     PyObject *callable;
     unsigned int num = 1;
     int blocking = 0;
-    int ensure_added = 0;
     static char *kwlist[] = {"callback", "num",
                              "blocking", NULL};
     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
@@ -1096,6 +1095,7 @@ pending_threadfunc(PyObject *self, PyObject *args, PyObject *kwargs)
     unsigned int num_added = 0;
     for (; num_added < num; num_added++) {
         if (_PyEval_AddPendingCall(interp, &_pending_callback, callable, 0) < 0) {
+            // out of memory and freelist is empty
             break;
         }
     }
@@ -1152,14 +1152,14 @@ pending_identify(PyObject *self, PyObject *args)
     PyThread_acquire_lock(mutex, WAIT_LOCK);
     /* It gets released in _pending_identify_callback(). */
 
-    int r;
-    do {
-        Py_BEGIN_ALLOW_THREADS
-        r = _PyEval_AddPendingCall(interp,
-                                   &_pending_identify_callback, (void *)mutex,
-                                   0);
-        Py_END_ALLOW_THREADS
-    } while (r < 0);
+
+    Py_BEGIN_ALLOW_THREADS
+    int r = _PyEval_AddPendingCall(interp,
+                               &_pending_identify_callback, (void *)mutex,
+                               0);
+    (void)r;
+    assert(r == 0);
+    Py_END_ALLOW_THREADS
 
     /* Wait for the pending call to complete. */
     PyThread_acquire_lock(mutex, WAIT_LOCK);