Address Tim's review comments.

* Made test for the zero argument case explicit.
* Use exactly representable numbers in the extreme small value tests.
* Guard against a malicious __float__ that succeeds on the first call
  and fails on the second.

Lib/test/test_math.py

@@ -745,6 +745,7 @@ def testHypot(self):
         # Test corner cases
         self.assertEqual(hypot(0.0, 0.0), 0.0)     # Max input is zero
         self.assertEqual(hypot(-10.5), 10.5)       # Negative input
+        self.assertEqual(hypot(), 0.0)             # Negative input
 
         # Test handling of bad arguments
         with self.assertRaises(TypeError):         # Reject keyword args
@@ -781,7 +782,7 @@ def testHypot(self):
         # Verify scaling for extremely small values
         for exp in range(32):
             scale = FLOAT_MIN / 2.0 ** exp
-            self.assertEqual(math.hypot(12*scale, 5*scale), 13*scale)
+            self.assertEqual(math.hypot(4*scale, 3*scale), 5*scale)
 
     def testLdexp(self):
         self.assertRaises(TypeError, math.ldexp)

Modules/mathmodule.c

@@ -2068,7 +2068,11 @@ math_hypot(PyObject *self, PyObject *args)
     }
     for (i=0 ; i<n ; i++) {
         item = PyTuple_GET_ITEM(args, i);
-        x = PyFloat_AsDouble(item) / max;
+        x = PyFloat_AsDouble(item);
+        if (x == -1.0 && PyErr_Occurred()) {
+            return NULL;
+        }
+        x /= max;
         csum += x * x;
     }
     return PyFloat_FromDouble(max * sqrt(csum));       // XXX Handle overflow