python
diff --git a/‎Doc/c-api/hash.rst
Lines changed: 4 additions & 4 deletions b/‎Doc/c-api/hash.rst
Lines changed: 4 additions & 4 deletions
diff --git a/‎Lib/test/test_capi/test_hash.py
Lines changed: 5 additions & 2 deletions b/‎Lib/test/test_capi/test_hash.py
Lines changed: 5 additions & 2 deletions
diff --git a/‎Python/pyhash.c
Lines changed: 4 additions & 4 deletions b/‎Python/pyhash.c
Lines changed: 4 additions & 4 deletions
@@ -52,16 +52,16 @@ Functions
 
    Hash a C double number.
 
-   * Set *\*result* to the hash and return ``1`` if *value* is finite or is
+   * Set *\*result* to the hash and return ``0`` if *value* is finite or is
      infinity.
    * Set *\*result* to :data:`sys.hash_info.nan <sys.hash_info>` (``0``) and
-     return ``0`` if *value* is not-a-number (NaN).
+     return ``1`` if *value* is not-a-number (NaN).
 
    *result* must not be ``NULL``.
 
    .. note::
-      Only rely on the function return value to distinguish the "not-a-number"
-      case. *\*result* can be ``0`` if *value* is finite. For example,
+      Only rely on the function return value to distinguish the not-a-number
+      (NaN) case. *\*result* can be ``0`` if *value* is finite. For example,
       ``Py_HashDouble(0.0, &result)`` sets *\*result* to 0.
 
    .. versionadded:: 3.13
 
@@ -35,10 +35,13 @@ def test_hash_getfuncdef(self):
 
     def test_hash_double(self):
         # Test Py_HashDouble()
+        #
+        # _Py_HashDouble() is tested indirectly by test_float in test_hash()
+        # and test_hash_nan().
         hash_double = _testcapi.hash_double
 
         def check_number(value, expected):
-            self.assertEqual(hash_double(value), (1, expected))
+            self.assertEqual(hash_double(value), (0, expected))
 
         # test some integers
         integers = [
@@ -74,4 +77,4 @@ def check_number(value, expected):
                 check_number(-x, hash(-x))
 
         # test not-a-number (NaN)
-        self.assertEqual(hash_double(float('nan')), (0, sys.hash_info.nan))
+        self.assertEqual(hash_double(float('nan')), (1, sys.hash_info.nan))
@@ -95,12 +95,12 @@ Py_HashDouble(double v, Py_hash_t *result)
     if (!Py_IS_FINITE(v)) {
         if (Py_IS_INFINITY(v)) {
             *result = (v > 0 ? _PyHASH_INF : -_PyHASH_INF);
-            return 1;
+            return 0;
         }
         else {
             assert(Py_IS_NAN(v));
             *result = _PyHASH_NAN;
-            return 0;
+            return 1;
         }
     }
 
@@ -134,7 +134,7 @@ Py_HashDouble(double v, Py_hash_t *result)
     if (x == (Py_uhash_t)-1)
         x = (Py_uhash_t)-2;
     *result = (Py_hash_t)x;
-    return 1;
+    return 0;
 }
 
 Py_hash_t
@@ -143,7 +143,7 @@ _Py_HashDouble(PyObject *obj, double v)
     assert(obj != NULL);
 
     Py_hash_t hash;
-    if (Py_HashDouble(v, &hash) == 0) {
+    if (Py_HashDouble(v, &hash) == 1) {
         hash = _Py_HashPointer(obj);
     }
     return hash;
Original file line number	Diff line number	Diff line change
`@@ -95,12 +95,12 @@ Py_HashDouble(double v, Py_hash_t *result)`
`95`	`95`	`if (!Py_IS_FINITE(v)) {`
`96`	`96`	`if (Py_IS_INFINITY(v)) {`
`97`	`97`	`*result = (v > 0 ? _PyHASH_INF : -_PyHASH_INF);`
`98`		`- return 1;`
	`98`	`+ return 0;`
`99`	`99`	`}`
`100`	`100`	`else {`
`101`	`101`	`assert(Py_IS_NAN(v));`
`102`	`102`	`*result = _PyHASH_NAN;`
`103`		`- return 0;`
	`103`	`+ return 1;`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -134,7 +134,7 @@ Py_HashDouble(double v, Py_hash_t *result)`
`134`	`134`	`if (x == (Py_uhash_t)-1)`
`135`	`135`	`x = (Py_uhash_t)-2;`
`136`	`136`	`*result = (Py_hash_t)x;`
`137`		`- return 1;`
	`137`	`+ return 0;`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`Py_hash_t`
`@@ -143,7 +143,7 @@ _Py_HashDouble(PyObject *obj, double v)`
`143`	`143`	`assert(obj != NULL);`
`144`	`144`
`145`	`145`	`Py_hash_t hash;`
`146`		`- if (Py_HashDouble(v, &hash) == 0) {`
	`146`	`+ if (Py_HashDouble(v, &hash) == 1) {`
`147`	`147`	`hash = _Py_HashPointer(obj);`
`148`	`148`	`}`
`149`	`149`	`return hash;`