Apply 'asserts' fixer

This just updates unittest method names.

3 files changed, 86 insertions, 86 deletions

diff --git a/test/test_byterange.py b/test/test_byterange.py
index 3462ee0..dfed311 100644
--- a/test/test_byterange.py
+++ b/test/test_byterange.py
@@ -53,37 +53,37 @@ class RangeableFileObjectTestCase(TestCase):
     def test_seek(self):
         """RangeableFileObject.seek()"""
         self.rfo.seek(11)
-        self.assertEquals('24', self.rfo.read(2))
+        self.assertEqual('24', self.rfo.read(2))
         self.rfo.seek(14)
-        self.assertEquals('volumes', self.rfo.read(7))
+        self.assertEqual('volumes', self.rfo.read(7))
         self.rfo.seek(1,1)
-        self.assertEquals('of', self.rfo.read(2))
+        self.assertEqual('of', self.rfo.read(2))
 
     def test_read(self):
         """RangeableFileObject.read()"""
-        self.assertEquals('the', self.rfo.read(3))
-        self.assertEquals(' entire 24 volumes of ', self.rfo.read(22))
-        self.assertEquals('Encyclopaedia\nBrittanica', self.rfo.read(50))
-        self.assertEquals('', self.rfo.read())
+        self.assertEqual('the', self.rfo.read(3))
+        self.assertEqual(' entire 24 volumes of ', self.rfo.read(22))
+        self.assertEqual('Encyclopaedia\nBrittanica', self.rfo.read(50))
+        self.assertEqual('', self.rfo.read())
 
     def test_readall(self):
         """RangeableFileObject.read(): to end of file."""
         rfo = RangeableFileObject(StringIO(self.test),(11,))
-        self.assertEquals(self.test[11:],rfo.read())
+        self.assertEqual(self.test[11:],rfo.read())
 
     def test_readline(self):
         """RangeableFileObject.readline()"""
-        self.assertEquals('the entire 24 volumes of Encyclopaedia\n', self.rfo.readline())
-        self.assertEquals('Brittanica', self.rfo.readline())
-        self.assertEquals('', self.rfo.readline())
+        self.assertEqual('the entire 24 volumes of Encyclopaedia\n', self.rfo.readline())
+        self.assertEqual('Brittanica', self.rfo.readline())
+        self.assertEqual('', self.rfo.readline())
 
     def test_tell(self):
         """RangeableFileObject.tell()"""
-        self.assertEquals(0,self.rfo.tell())
+        self.assertEqual(0,self.rfo.tell())
         self.rfo.read(5)
-        self.assertEquals(5,self.rfo.tell())
+        self.assertEqual(5,self.rfo.tell())
         self.rfo.readline()
-        self.assertEquals(39,self.rfo.tell())
+        self.assertEqual(39,self.rfo.tell())
 
 class RangeModuleTestCase(TestCase):
     """Test module level functions defined in range.py"""
@@ -107,7 +107,7 @@ class RangeModuleTestCase(TestCase):
                     (None, None)
                  )
         for test, ex in tests:
-            self.assertEquals( range_tuple_normalize(test), ex )
+            self.assertEqual( range_tuple_normalize(test), ex )
 
         try: range_tuple_normalize( (10,8) )
         except RangeError: pass
@@ -123,7 +123,7 @@ class RangeModuleTestCase(TestCase):
                     (None, None)
                  )
         for test, ex in tests:
-            self.assertEquals( range_header_to_tuple(test), ex )
+            self.assertEqual( range_header_to_tuple(test), ex )
 
     def test_range_tuple_to_header(self):
         """byterange.range_tuple_to_header()"""
@@ -137,7 +137,7 @@ class RangeModuleTestCase(TestCase):
                     (None, None),
                  )
         for test, ex in tests:
-            self.assertEquals( range_tuple_to_header(test), ex )
+            self.assertEqual( range_tuple_to_header(test), ex )
 
         try: range_tuple_to_header( ('not an int',500) )
         except ValueError: pass
diff --git a/test/test_grabber.py b/test/test_grabber.py
index 9894a74..465e5f5 100644
--- a/test/test_grabber.py
+++ b/test/test_grabber.py
@@ -73,7 +73,7 @@ class FileObjectTests(TestCase):
         "PYCurlFileObject .read() method"
         s = self.wrapper.read()
         self.fo_output.write(s)
-        self.assert_(reference_data == self.fo_output.getvalue())
+        self.assertTrue(reference_data == self.fo_output.getvalue())
 
     def test_readline(self):
         "PyCurlFileObject .readline() method"
@@ -81,13 +81,13 @@ class FileObjectTests(TestCase):
             s = self.wrapper.readline()
             self.fo_output.write(s)
             if not s: break
-        self.assert_(reference_data == self.fo_output.getvalue())
+        self.assertTrue(reference_data == self.fo_output.getvalue())
 
     def test_readlines(self):
         "PyCurlFileObject .readlines() method"
         li = self.wrapper.readlines()
         self.fo_output.write(b''.join(li))
-        self.assert_(reference_data == self.fo_output.getvalue())
+        self.assertTrue(reference_data == self.fo_output.getvalue())
 
     def test_smallread(self):
         "PyCurlFileObject .read(N) with small N"
@@ -95,7 +95,7 @@ class FileObjectTests(TestCase):
             s = self.wrapper.read(23)
             self.fo_output.write(s)
             if not s: break
-        self.assert_(reference_data == self.fo_output.getvalue())
+        self.assertTrue(reference_data == self.fo_output.getvalue())
 
 class HTTPTests(TestCase):
     def test_reference_file(self):
@@ -105,7 +105,7 @@ class HTTPTests(TestCase):
 
         contents = open(filename, 'rb').read()
 
-        self.assert_(contents == reference_data)
+        self.assertTrue(contents == reference_data)
 
     def test_post(self):
         "do an HTTP post"
@@ -171,38 +171,38 @@ class URLGrabberTestCase(TestCase):
                         proxies={'http' : 'http://www.proxy.com:9090'},
                         opener=opener )
         opts = g.opts
-        self.assertEquals( opts.progress_obj, self.meter )
-        self.assertEquals( opts.throttle, 0.9 )
-        self.assertEquals( opts.bandwidth, 20 )
-        self.assertEquals( opts.retry, 20 )
-        self.assertEquals( opts.retrycodes, [5,6,7] )
-        self.assertEquals( opts.copy_local, 1 )
-        self.assertEquals( opts.close_connection, 1 )
-        self.assertEquals( opts.user_agent, 'test ua/1.0' )
-        self.assertEquals( opts.proxies, {'http' : 'http://www.proxy.com:9090'} )
-        self.assertEquals( opts.opener, opener )
+        self.assertEqual( opts.progress_obj, self.meter )
+        self.assertEqual( opts.throttle, 0.9 )
+        self.assertEqual( opts.bandwidth, 20 )
+        self.assertEqual( opts.retry, 20 )
+        self.assertEqual( opts.retrycodes, [5,6,7] )
+        self.assertEqual( opts.copy_local, 1 )
+        self.assertEqual( opts.close_connection, 1 )
+        self.assertEqual( opts.user_agent, 'test ua/1.0' )
+        self.assertEqual( opts.proxies, {'http' : 'http://www.proxy.com:9090'} )
+        self.assertEqual( opts.opener, opener )
 
         nopts = grabber.URLGrabberOptions(delegate=opts, throttle=0.5,
                                         copy_local=0)
-        self.assertEquals( nopts.progress_obj, self.meter )
-        self.assertEquals( nopts.throttle, 0.5 )
-        self.assertEquals( nopts.bandwidth, 20 )
-        self.assertEquals( nopts.retry, 20 )
-        self.assertEquals( nopts.retrycodes, [5,6,7] )
-        self.assertEquals( nopts.copy_local, 0 )
-        self.assertEquals( nopts.close_connection, 1 )
-        self.assertEquals( nopts.user_agent, 'test ua/1.0' )
-        self.assertEquals( nopts.proxies, {'http' : 'http://www.proxy.com:9090'} )
+        self.assertEqual( nopts.progress_obj, self.meter )
+        self.assertEqual( nopts.throttle, 0.5 )
+        self.assertEqual( nopts.bandwidth, 20 )
+        self.assertEqual( nopts.retry, 20 )
+        self.assertEqual( nopts.retrycodes, [5,6,7] )
+        self.assertEqual( nopts.copy_local, 0 )
+        self.assertEqual( nopts.close_connection, 1 )
+        self.assertEqual( nopts.user_agent, 'test ua/1.0' )
+        self.assertEqual( nopts.proxies, {'http' : 'http://www.proxy.com:9090'} )
         nopts.opener = None
-        self.assertEquals( nopts.opener, None )
+        self.assertEqual( nopts.opener, None )
 
     def test_make_callback(self):
         """grabber.URLGrabber._make_callback() tests"""
         def cb(e): pass
         tup_cb = (cb, ('stuff'), {'some': 'dict'})
         g = URLGrabber()
-        self.assertEquals(g._make_callback(cb),     (cb, (), {}))
-        self.assertEquals(g._make_callback(tup_cb), tup_cb)
+        self.assertEqual(g._make_callback(cb),     (cb, (), {}))
+        self.assertEqual(g._make_callback(tup_cb), tup_cb)
 
 class URLParserTestCase(TestCase):
     def setUp(self):
@@ -221,7 +221,7 @@ class URLParserTestCase(TestCase):
         for b in bases:
             g = URLGrabber(prefix=b)
             (url, parts) = g.opts.urlparser.parse(filename, g.opts)
-            self.assertEquals(url, target)
+            self.assertEqual(url, target)
 
     def _test_url(self, urllist):
         g = URLGrabber()
@@ -234,8 +234,8 @@ class URLParserTestCase(TestCase):
         (url, parts) = g.opts.urlparser.parse(url, g.opts)
 
         if 1:
-            self.assertEquals(url, expected_url)
-            self.assertEquals(parts, expected_parts)
+            self.assertEqual(url, expected_url)
+            self.assertEqual(parts, expected_parts)
         else:
             if url == urllist[1] and parts == urllist[2]:
                 print('OK: %s' % urllist[0])
@@ -317,7 +317,7 @@ class FailureTestCase(TestCase):
                                failure_callback=self._failure_callback)
         try: g.urlgrab(ref_404)
         except URLGrabError: pass
-        self.assertEquals(self.failure_callback_called, 1)
+        self.assertEqual(self.failure_callback_called, 1)
 
     def test_failure_callback_args(self):
         "failure callback is called with the proper args"
@@ -326,17 +326,17 @@ class FailureTestCase(TestCase):
                                failure_callback=fc)
         try: g.urlgrab(ref_404)
         except URLGrabError: pass
-        self.assert_(hasattr(self, 'obj'))
-        self.assert_(hasattr(self, 'args'))
-        self.assert_(hasattr(self, 'kwargs'))
-        self.assertEquals(self.args, ('foo',))
-        self.assertEquals(self.kwargs, {'bar': 'baz'})
-        self.assert_(isinstance(self.obj, CallbackObject))
+        self.assertTrue(hasattr(self, 'obj'))
+        self.assertTrue(hasattr(self, 'args'))
+        self.assertTrue(hasattr(self, 'kwargs'))
+        self.assertEqual(self.args, ('foo',))
+        self.assertEqual(self.kwargs, {'bar': 'baz'})
+        self.assertTrue(isinstance(self.obj, CallbackObject))
         url = self.obj.url
         if not isinstance(url, string_types):
             url = url.decode('utf8')
-        self.assertEquals(url, ref_404)
-        self.assert_(isinstance(self.obj.exception, URLGrabError))
+        self.assertEqual(url, ref_404)
+        self.assertTrue(isinstance(self.obj.exception, URLGrabError))
         del self.obj
 
 class InterruptTestCase(TestCase):
@@ -365,7 +365,7 @@ class InterruptTestCase(TestCase):
                                interrupt_callback=ic)
         try: g.urlgrab(ref_http)
         except KeyboardInterrupt: pass
-        self.assertEquals(self.interrupt_callback_called, 1)
+        self.assertEqual(self.interrupt_callback_called, 1)
 
     def test_interrupt_callback_raises(self):
         "interrupt callback raises an exception"
@@ -406,28 +406,28 @@ class CheckfuncTestCase(TestCase):
 
     def _check_common_args(self):
         "check the args that are common to both urlgrab and urlread"
-        self.assert_(hasattr(self, 'obj'))
-        self.assert_(hasattr(self, 'args'))
-        self.assert_(hasattr(self, 'kwargs'))
-        self.assertEquals(self.args, ('foo',))
-        self.assertEquals(self.kwargs, {'bar': 'baz'})
-        self.assert_(isinstance(self.obj, CallbackObject))
+        self.assertTrue(hasattr(self, 'obj'))
+        self.assertTrue(hasattr(self, 'args'))
+        self.assertTrue(hasattr(self, 'kwargs'))
+        self.assertEqual(self.args, ('foo',))
+        self.assertEqual(self.kwargs, {'bar': 'baz'})
+        self.assertTrue(isinstance(self.obj, CallbackObject))
         url = self.obj.url
         if not isinstance(url, string_types):
             url = url.decode()
-        self.assertEquals(url, short_ref_http)
+        self.assertEqual(url, short_ref_http)
 
     def test_checkfunc_urlgrab_args(self):
         "check for proper args when used with urlgrab"
         self.g.urlgrab(short_ref_http, self.filename)
         self._check_common_args()
-        self.assertEquals(self.obj.filename, self.filename)
+        self.assertEqual(self.obj.filename, self.filename)
 
     def test_checkfunc_urlread_args(self):
         "check for proper args when used with urlread"
         self.g.urlread(short_ref_http)
         self._check_common_args()
-        self.assertEquals(self.obj.data, short_reference_data)
+        self.assertEqual(self.obj.data, short_reference_data)
 
     def test_checkfunc_urlgrab_success(self):
         "check success with urlgrab checkfunc"
@@ -494,8 +494,8 @@ class FTPRegetTests(RegetTestBase, TestCase):
         self.grabber.urlgrab(self.url, self.filename, reget='simple')
         data = self._read_file()
 
-        self.assertEquals(data[:self.hl], b'0'*self.hl)
-        self.assertEquals(data[self.hl:], self.ref[self.hl:])
+        self.assertEqual(data[:self.hl], b'0'*self.hl)
+        self.assertEqual(data[self.hl:], self.ref[self.hl:])
 
 class HTTPRegetTests(FTPRegetTests):
     def setUp(self):
@@ -516,8 +516,8 @@ class HTTPRegetTests(FTPRegetTests):
 
         data = self._read_file()
 
-        self.assertEquals(data[:self.hl], b'0'*self.hl)
-        self.assertEquals(data[self.hl:], self.ref[self.hl:])
+        self.assertEqual(data[:self.hl], b'0'*self.hl)
+        self.assertEqual(data[self.hl:], self.ref[self.hl:])
 
     def test_newer_check_timestamp(self):
         # define this here rather than in the FTP tests because currently,
@@ -533,7 +533,7 @@ class HTTPRegetTests(FTPRegetTests):
 
         data = self._read_file()
 
-        self.assertEquals(data, self.ref)
+        self.assertEqual(data, self.ref)
 
 class FileRegetTests(HTTPRegetTests):
     def setUp(self):
diff --git a/test/test_mirror.py b/test/test_mirror.py
index 5a23c51..a2daf19 100644
--- a/test/test_mirror.py
+++ b/test/test_mirror.py
@@ -112,8 +112,8 @@ class CallbackTests(TestCase):
             tl.append(str(cb_obj.exception))
         self.mg.failure_callback = failure_callback, (tricky_list, ), {}
         data = self.mg.urlread('reference')
-        self.assert_(data == reference_data)
-        self.assertEquals(tricky_list[0][:25],
+        self.assertTrue(data == reference_data)
+        self.assertEqual(tricky_list[0][:25],
                           '[Errno 14] HTTP Error 404')
 
     def test_callback_reraise(self):
@@ -200,8 +200,8 @@ class ActionTests(TestCase):
              'MAIN mirrors: [a b c d e f] 2',
              'MIRROR: trying somefile -> c/somefile']
 
-        self.assertEquals(self.g.calls, expected_calls)
-        self.assertEquals(urlgrabber.mirror.DEBUG.logs, expected_logs)
+        self.assertEqual(self.g.calls, expected_calls)
+        self.assertEqual(urlgrabber.mirror.DEBUG.logs, expected_logs)
 
     def test_instance_action(self):
         'test the effects of passed-in default_action'
@@ -220,8 +220,8 @@ class ActionTests(TestCase):
              'MAIN mirrors: [c d e f] 0',
              'MIRROR: trying somefile -> c/somefile']
 
-        self.assertEquals(self.g.calls, expected_calls)
-        self.assertEquals(urlgrabber.mirror.DEBUG.logs, expected_logs)
+        self.assertEqual(self.g.calls, expected_calls)
+        self.assertEqual(urlgrabber.mirror.DEBUG.logs, expected_logs)
 
     def test_method_action(self):
         'test the effects of method-level default_action'
@@ -239,8 +239,8 @@ class ActionTests(TestCase):
              'MAIN mirrors: [c d e f] 0',
              'MIRROR: trying somefile -> c/somefile']
 
-        self.assertEquals(self.g.calls, expected_calls)
-        self.assertEquals(urlgrabber.mirror.DEBUG.logs, expected_logs)
+        self.assertEqual(self.g.calls, expected_calls)
+        self.assertEqual(urlgrabber.mirror.DEBUG.logs, expected_logs)
 
 
     def callback(self, e): return {'fail': 1}
@@ -257,8 +257,8 @@ class ActionTests(TestCase):
                        'GR   mirrors: [b c d e f] 0',
                        'MAIN mirrors: [a b c d e f] 1']
 
-        self.assertEquals(self.g.calls, expected_calls)
-        self.assertEquals(urlgrabber.mirror.DEBUG.logs, expected_logs)
+        self.assertEqual(self.g.calls, expected_calls)
+        self.assertEqual(urlgrabber.mirror.DEBUG.logs, expected_logs)
 
 import threading, socket
 
@@ -319,14 +319,14 @@ class HttpReplyCode(TestCase):
 
         # single
         self.assertRaises(URLGrabError, self.mg.urlgrab, 'foo')
-        self.assertEquals(self.code, 503); del self.code
+        self.assertEqual(self.code, 503); del self.code
 
         # multi
         err = []
         self.mg.urlgrab('foo', async_=True, failfunc=err.append)
         urlgrabber.grabber.parallel_wait()
-        self.assertEquals([e.exception.errno for e in err], [256])
-        self.assertEquals(self.code, 503); del self.code
+        self.assertEqual([e.exception.errno for e in err], [256])
+        self.assertEqual(self.code, 503); del self.code
 
     def test_range(self):
         'test client-side processing of HTTP ranges'
@@ -336,10 +336,10 @@ class HttpReplyCode(TestCase):
 
         # no range specified
         data = self.mg.urlread('foo')
-        self.assertEquals(data, b'ABCDEF')
+        self.assertEqual(data, b'ABCDEF')
 
         data = self.mg.urlread('foo', range = (3, 5))
-        self.assertEquals(data, b'DE')
+        self.assertEqual(data, b'DE')
 
     def test_retry_no_cache(self):
         'test bypassing proxy cache on failure'