wulczer
diff --git a/‎test/test_retrying.py
Lines changed: 14 additions & 14 deletions b/‎test/test_retrying.py
Lines changed: 14 additions & 14 deletions
diff --git a/‎txpostgres/retrying.py
Lines changed: 1 addition & 1 deletion b/‎txpostgres/retrying.py
Lines changed: 1 addition & 1 deletion
@@ -18,9 +18,9 @@ def test_simple(self):
         it = retrying.simpleBackoffIterator()
 
         # by default "now" is set
-        self.assertEquals(it.next(), 0)
+        self.assertEquals(next(it), 0)
 
-        r1, r2, r3 = it.next(), it.next(), it.next()
+        r1, r2, r3 = next(it), next(it), next(it)
         self.assertTrue(r1 < r2 < r3)
 
     def test_maxDelay(self):
@@ -29,32 +29,32 @@ def test_maxDelay(self):
         """
         it = retrying.simpleBackoffIterator(maxDelay=2.0)
 
-        res = [it.next() for _ in range(5)]
+        res = [next(it) for _ in range(5)]
         self.assertEquals(res[-1], 2.0)
 
     def test_notNow(self):
         """
         If now is not set, the first delay is not zero.
         """
         it = retrying.simpleBackoffIterator(now=False)
-        self.assertNotEquals(it.next(), 0)
+        self.assertNotEquals(next(it), 0)
 
     def test_maxRetries(self):
         """
         The iterator gets exhausted if retries are capped.
         """
         it = retrying.simpleBackoffIterator(maxRetries=3)
 
-        it.next(), it.next(), it.next()
-        self.assertRaises(StopIteration, it.next)
+        next(it), next(it), next(it)
+        self.assertRaises(StopIteration, lambda: next(it))
 
     def test_noMaxRetries(self):
         """
         The iterator does not get exhausted if retries are not capped.
         """
         it = retrying.simpleBackoffIterator(maxRetries=0, maxDelay=1)
 
-        alot = [it.next() for _ in range(1000)]
+        alot = [next(it) for _ in range(1000)]
         self.assertEquals(alot[-1], 1)
 
     def test_noMaxDelay(self):
@@ -64,7 +64,7 @@ def test_noMaxDelay(self):
         it = retrying.simpleBackoffIterator(maxRetries=0, maxDelay=0)
 
         # putting range(1000) here makes Python return a NaN, so be moderate
-        alot = [it.next() for _ in range(100)]
+        alot = [next(it) for _ in range(100)]
         self.assertTrue(alot[-2] < alot[-1])
 
     def test_precise(self):
@@ -75,12 +75,12 @@ def test_precise(self):
         it = retrying.simpleBackoffIterator(initialDelay=10, maxDelay=90,
                                             factor=2, jitter=0)
 
-        self.assertEquals(it.next(), 0)
-        self.assertEquals(it.next(), 20)
-        self.assertEquals(it.next(), 40)
-        self.assertEquals(it.next(), 80)
-        self.assertEquals(it.next(), 90)
-        self.assertEquals(it.next(), 90)
+        self.assertEquals(
B4E9
next(it), 0)
+        self.assertEquals(next(it), 20)
+        self.assertEquals(next(it), 40)
+        self.assertEquals(next(it), 80)
+        self.assertEquals(next(it), 90)
+        self.assertEquals(next(it), 90)
 
 
 class TestRetryingCall(unittest.TestCase):
 
@@ -111,7 +111,7 @@ def _err(self, fail):
 
     def _call(self):
         try:
-            delay = self._backoffIterator.next()
+            delay = next(self._backoffIterator)
         except StopIteration:
             self._deferred.errback(self.failure)
         else: