merge

Doc/library/unittest.mock.rst

@@ -1354,8 +1354,12 @@ method of a `TestCase`:
     As an added bonus you no longer need to keep a reference to the `patcher`
     object.
 
-In fact `start` and `stop` are just aliases for the context manager
-`__enter__` and `__exit__` methods.
+It is also possible to stop all patches which have been started by using
+`patch.stopall`.
+
+.. function:: patch.stopall
+
+    Stop all active patches. Only stops patches started with `start`.
 
 
 TEST_PREFIX

Lib/concurrent/futures/_base.py

@@ -470,8 +470,8 @@ class Future(object):
                 return True
             else:
                 LOGGER.critical('Future %s in unexpected state: %s',
-                                id(self.future),
-                                self.future._state)
+                                id(self),
+                                self._state)
                 raise RuntimeError('Future in unexpected state')
 
     def set_result(self, result):

Lib/unittest/mock.py

@@ -1002,6 +1002,7 @@ def _is_started(patcher):
 class _patch(object):
 
     attribute_name = None
+    _active_patches = set()
 
     def __init__(
             self, getter, attribute, new, spec, create,
@@ -1270,8 +1271,18 @@ class _patch(object):
             if _is_started(patcher):
                 patcher.__exit__(*exc_info)
 
-    start = __enter__
-    stop = __exit__
+
+    def start(self):
+        """Activate a patch, returning any created mock."""
+        result = self.__enter__()
+        self._active_patches.add(self)
+        return result
+
+
+    def stop(self):
+        """Stop an active patch."""
+        self._active_patches.discard(self)
+        return self.__exit__()
 
 
 
@@ -1562,9 +1573,16 @@ def _clear_dict(in_dict):
             del in_dict[key]
 
 
+def _patch_stopall():
+    """Stop all active patches."""
+    for patch in list(_patch._active_patches):
+        patch.stop()
+
+
 patch.object = _patch_object
 patch.dict = _patch_dict
 patch.multiple = _patch_multiple
+patch.stopall = _patch_stopall
 patch.TEST_PREFIX = 'test'
 
 magic_methods = (

Lib/unittest/test/testmock/testpatch.py

@@ -1762,6 +1762,24 @@ class PatchTest(unittest.TestCase):
             p.stop()
 
 
+    def test_patch_stopall(self):
+        unlink = os.unlink
+        chdir = os.chdir
+        path = os.path
+        patch('os.unlink', something).start()
+        patch('os.chdir', something_else).start()
+
+        @patch('os.path')
+        def patched(mock_path):
+            patch.stopall()
+            self.assertIs(os.path, mock_path)
+            self.assertIs(os.unlink, unlink)
+            self.assertIs(os.chdir, chdir)
+
+        patched()
+        self.assertIs(os.path, path)
+
+
 
 if __name__ == '__main__':
     unittest.main()

Modules/_decimal/libmpdec/mpdecimal.c

@@ -5713,30 +5713,28 @@ void
 mpd_qnext_minus(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
                 uint32_t *status)
 {
-    mpd_context_t workctx; /* function context */
+    mpd_context_t workctx;
     MPD_NEW_CONST(tiny,MPD_POS,mpd_etiny(ctx)-1,1,1,1,1);
 
     if (mpd_isspecial(a)) {
         if (mpd_qcheck_nan(result, a, ctx, status)) {
             return;
         }
-        if (mpd_isinfinite(a)) {
-            if (mpd_isnegative(a)) {
-                mpd_qcopy(result, a, status);
-                return;
-            }
-            else {
-                mpd_clear_flags(result);
-                mpd_qmaxcoeff(result, ctx, status);
-                if (mpd_isnan(result)) {
-                    return;
-                }
-                result->exp = ctx->emax - ctx->prec + 1;
-                return;
-            }
+
+        assert(mpd_isinfinite(a));
+        if (mpd_isnegative(a)) {
+            mpd_qcopy(result, a, status);
+            return;
+        }
+        else {
+            mpd_clear_flags(result);
+            mpd_qmaxcoeff(result, ctx, status);
+            if (mpd_isnan(result)) {
+                return;
+            }
+            result->exp = mpd_etop(ctx);
+            return;
         }
-        /* debug */
-        abort(); /* GCOV_NOT_REACHED */
     }
 
     mpd_workcontext(&workctx, ctx);
@@ -5769,21 +5767,21 @@ mpd_qnext_plus(mpd_t *result, const mpd_t *a, const mpd_context_t *ctx,
         if (mpd_qcheck_nan(result, a, ctx, status)) {
             return;
         }
-        if (mpd_isinfinite(a)) {
-            if (mpd_ispositive(a)) {
-                mpd_qcopy(result, a, status);
-            }
-            else {
-                mpd_clear_flags(result);
-                mpd_qmaxcoeff(result, ctx, status);
-                if (mpd_isnan(result)) {
-                    return;
-                }
-                mpd_set_flags(result, MPD_NEG);
-                result->exp = mpd_etop(ctx);
-            }
-            return;
+
+        assert(mpd_isinfinite(a));
+        if (mpd_ispositive(a)) {
+            mpd_qcopy(result, a, status);
         }
+        else {
+            mpd_clear_flags(result);
+            mpd_qmaxcoeff(result, ctx, status);
+            if (mpd_isnan(result)) {
+                return;
+            }
+            mpd_set_flags(result, MPD_NEG);
+            result->exp = mpd_etop(ctx);
+        }
+        return;
     }
 
     mpd_workcontext(&workctx, ctx);
@@ -5814,9 +5812,8 @@ mpd_qnext_toward(mpd_t *result, const mpd_t *a, const mpd_t *b,
 {
     int c;
 
-    if (mpd_isnan(a) || mpd_isnan(b)) {
-        if (mpd_qcheck_nans(result, a, b, ctx, status))
-            return;
+    if (mpd_qcheck_nans(result, a, b, ctx, status)) {
+        return;
     }
 
     c = _mpd_cmp(a, b);