avoid deprecated unittest functions

9 files changed, 74 insertions, 74 deletions

diff --git a/test/test.py b/test/test.py
index 42936b7..83f380e 100644
--- a/test/test.py
+++ b/test/test.py
@@ -56,7 +56,7 @@ class Test4_Nonblocking(unittest.TestCase):
 
     def test1_ReadEmpty(self):
         """timeout: After port open, the input buffer must be empty"""
-        self.failUnlessEqual(self.s.read(1), b'', "expected empty buffer")
+        self.assertEqual(self.s.read(1), b'', "expected empty buffer")
 
     def test2_Loopback(self):
         """timeout: each sent character should return (binary test).
@@ -66,9 +66,9 @@ class Test4_Nonblocking(unittest.TestCase):
             self.s.write(block)
             # there might be a small delay until the character is ready (especially on win32)
             time.sleep(0.05)
-            self.failUnlessEqual(self.s.in_waiting, length, "expected exactly %d character for inWainting()" % length)
-            self.failUnlessEqual(self.s.read(length), block)#, "expected a %r which was written before" % block)
-        self.failUnlessEqual(self.s.read(1), b'', "expected empty buffer after all sent chars are read")
+            self.assertEqual(self.s.in_waiting, length, "expected exactly %d character for inWainting()" % length)
+            self.assertEqual(self.s.read(length), block)#, "expected a %r which was written before" % block)
+        self.assertEqual(self.s.read(1), b'', "expected empty buffer after all sent chars are read")
 
     def test2_LoopbackTimeout(self):
         """timeout: test the timeout/immediate return.
@@ -76,8 +76,8 @@ class Test4_Nonblocking(unittest.TestCase):
         self.s.write(b"HELLO")
         time.sleep(0.1)    # there might be a small delay until the character is ready (especially on win32 and rfc2217)
         # read more characters as are available to run in the timeout
-        self.failUnlessEqual(self.s.read(10), b'HELLO', "expected the 'HELLO' which was written before")
-        self.failUnlessEqual(self.s.read(1), b'', "expected empty buffer after all sent chars are read")
+        self.assertEqual(self.s.read(10), b'HELLO', "expected the 'HELLO' which was written before")
+        self.assertEqual(self.s.read(1), b'', "expected empty buffer after all sent chars are read")
 
 
 class Test3_Timeout(Test4_Nonblocking):
@@ -143,7 +143,7 @@ class Test2_Forever(unittest.TestCase):
 
     def test1_inWaitingEmpty(self):
         """no timeout: after port open, the input buffer must be empty (in_waiting)"""
-        self.failUnlessEqual(self.s.in_waiting, 0, "expected empty buffer")
+        self.assertEqual(self.s.in_waiting, 0, "expected empty buffer")
 
     def test2_Loopback(self):
         """no timeout: each sent character should return (binary test).
@@ -153,9 +153,9 @@ class Test2_Forever(unittest.TestCase):
             self.s.write(block)
             # there might be a small delay until the character is ready (especially on win32 and rfc2217)
             time.sleep(0.05)
-            self.failUnlessEqual(self.s.in_waiting, length)#, "expected exactly %d character for inWainting()" % length)
-            self.failUnlessEqual(self.s.read(length), block) #, "expected %r which was written before" % block)
-        self.failUnlessEqual(self.s.in_waiting, 0, "expected empty buffer after all sent chars are read")
+            self.assertEqual(self.s.in_waiting, length)#, "expected exactly %d character for inWainting()" % length)
+            self.assertEqual(self.s.read(length), block) #, "expected %r which was written before" % block)
+        self.assertEqual(self.s.in_waiting, 0, "expected empty buffer after all sent chars are read")
 
 
 class Test0_DataWires(unittest.TestCase):
@@ -170,23 +170,23 @@ class Test0_DataWires(unittest.TestCase):
         """Test RTS/CTS"""
         self.s.rts = False
         time.sleep(1.1)
-        self.failUnless(not self.s.cts, "CTS -> 0")
+        self.assertTrue(not self.s.cts, "CTS -> 0")
         self.s.rts = True
         time.sleep(1.1)
-        self.failUnless(self.s.cts, "CTS -> 1")
+        self.assertTrue(self.s.cts, "CTS -> 1")
 
     def test2_DTR(self):
         """Test DTR/DSR"""
         self.s.dtr = False
         time.sleep(1.1)
-        self.failUnless(not self.s.dsr, "DSR -> 0")
+        self.assertTrue(not self.s.dsr, "DSR -> 0")
         self.s.dtr = True
         time.sleep(1.1)
-        self.failUnless(self.s.dsr, "DSR -> 1")
+        self.assertTrue(self.s.dsr, "DSR -> 1")
 
     def test3_RI(self):
         """Test RI"""
-        self.failUnless(not self.s.ri, "RI -> 0")
+        self.assertTrue(not self.s.ri, "RI -> 0")
 
 
 class Test_MoreTimeouts(unittest.TestCase):
@@ -215,9 +215,9 @@ class Test_MoreTimeouts(unittest.TestCase):
         self.s.write(serial.XOFF)
         time.sleep(0.5) # some systems need a little delay so that they can react on XOFF
         t1 = time.time()
-        self.failUnlessRaises(serial.SerialTimeoutException, self.s.write, b"timeout please"*200)
+        self.assertRaises(serial.SerialTimeoutException, self.s.write, b"timeout please"*200)
         t2 = time.time()
-        self.failUnless( 0.9 <= (t2-t1) < 2.1, "Timeout not in the given interval (%s)" % (t2-t1))
+        self.assertTrue( 0.9 <= (t2-t1) < 2.1, "Timeout not in the given interval (%s)" % (t2-t1))
 
 
 if __name__ == '__main__':
diff --git a/test/test_advanced.py b/test/test_advanced.py
index 29e32f8..8f83a40 100644
--- a/test/test_advanced.py
+++ b/test/test_advanced.py
@@ -39,14 +39,14 @@ class Test_ChangeAttributes(unittest.TestCase):
         self.s.port = PORT
         # portstr has to be set
         if isinstance(PORT, str):
-            self.failUnlessEqual(self.s.portstr.lower(), PORT.lower())
+            self.assertEqual(self.s.portstr.lower(), PORT.lower())
         else:
-            self.failUnlessEqual(self.s.portstr, serial.device(PORT))
+            self.assertEqual(self.s.portstr, serial.device(PORT))
         # test internals
-        self.failUnlessEqual(self.s._port, PORT)
+        self.assertEqual(self.s._port, PORT)
         # test on the fly change
         self.s.open()
-        self.failUnless(self.s.isOpen())
+        self.assertTrue(self.s.isOpen())
         #~ try:
             #~ self.s.port = 0
         #~ except serial.SerialException: # port not available on system
@@ -68,7 +68,7 @@ class Test_ChangeAttributes(unittest.TestCase):
         self.s.port = PORT
         self.s.open()
         # calling open for a second time is an error
-        self.failUnlessRaises(serial.SerialException, self.s.open)
+        self.assertRaises(serial.SerialException, self.s.open)
 
 
     def test_BaudrateSetting(self):
@@ -77,12 +77,12 @@ class Test_ChangeAttributes(unittest.TestCase):
         for baudrate in (300, 9600, 19200, 115200):
             self.s.baudrate = baudrate
             # test get method
-            self.failUnlessEqual(self.s.baudrate, baudrate)
+            self.assertEqual(self.s.baudrate, baudrate)
             # test internals
-            self.failUnlessEqual(self.s._baudrate, baudrate)
+            self.assertEqual(self.s._baudrate, baudrate)
         # test illegal values
         for illegal_value in (-300, -1, 'a', None):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'baudrate', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'baudrate', illegal_value)
 
     # skip this test as pyserial now tries to set even non standard baud rates.
     # therefore the test can not choose a value that fails on any system.
@@ -91,59 +91,59 @@ class Test_ChangeAttributes(unittest.TestCase):
         self.s.port = PORT
         self.s.open()
         for illegal_value in (500000, 576000, 921600, 92160):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'baudrate', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'baudrate', illegal_value)
 
     def test_BytesizeSetting(self):
         for bytesize in (5,6,7,8):
             self.s.bytesize = bytesize
             # test get method
-            self.failUnlessEqual(self.s.bytesize, bytesize)
+            self.assertEqual(self.s.bytesize, bytesize)
             # test internals
-            self.failUnlessEqual(self.s._bytesize, bytesize)
+            self.assertEqual(self.s._bytesize, bytesize)
         # test illegal values
         for illegal_value in (0, 1, 3, 4, 9, 10, 'a', None):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'bytesize', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'bytesize', illegal_value)
 
     def test_ParitySetting(self):
         for parity in (serial.PARITY_NONE, serial.PARITY_EVEN, serial.PARITY_ODD):
             self.s.parity = parity
             # test get method
-            self.failUnlessEqual(self.s.parity, parity)
+            self.assertEqual(self.s.parity, parity)
             # test internals
-            self.failUnlessEqual(self.s._parity, parity)
+            self.assertEqual(self.s._parity, parity)
         # test illegal values
         for illegal_value in (0, 57, 'a', None):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'parity', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'parity', illegal_value)
 
     def test_StopbitsSetting(self):
         for stopbits in (1, 2):
             self.s.stopbits = stopbits
             # test get method
-            self.failUnlessEqual(self.s.stopbits, stopbits)
+            self.assertEqual(self.s.stopbits, stopbits)
             # test internals
-            self.failUnlessEqual(self.s._stopbits, stopbits)
+            self.assertEqual(self.s._stopbits, stopbits)
         # test illegal values
         for illegal_value in (0, 3, 2.5, 57, 'a', None):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'stopbits', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'stopbits', illegal_value)
 
     def test_TimeoutSetting(self):
         for timeout in (None, 0, 1, 3.14159, 10, 1000, 3600):
             self.s.timeout = timeout
             # test get method
-            self.failUnlessEqual(self.s.timeout, timeout)
+            self.assertEqual(self.s.timeout, timeout)
             # test internals
-            self.failUnlessEqual(self.s._timeout, timeout)
+            self.assertEqual(self.s._timeout, timeout)
         # test illegal values
         for illegal_value in (-1, 'a'):
-            self.failUnlessRaises(ValueError, setattr, self.s, 'timeout', illegal_value)
+            self.assertRaises(ValueError, setattr, self.s, 'timeout', illegal_value)
 
     def test_XonXoffSetting(self):
         for xonxoff in (True, False):
             self.s.xonxoff = xonxoff
             # test get method
-            self.failUnlessEqual(self.s.xonxoff, xonxoff)
+            self.assertEqual(self.s.xonxoff, xonxoff)
             # test internals
-            self.failUnlessEqual(self.s._xonxoff, xonxoff)
+            self.assertEqual(self.s._xonxoff, xonxoff)
         # no illegal values here, normal rules for the boolean value of an
         # object are used thus all objects have a truth value.
 
@@ -151,9 +151,9 @@ class Test_ChangeAttributes(unittest.TestCase):
         for rtscts in (True, False):
             self.s.rtscts = rtscts
             # test get method
-            self.failUnlessEqual(self.s.rtscts, rtscts)
+            self.assertEqual(self.s.rtscts, rtscts)
             # test internals
-            self.failUnlessEqual(self.s._rtscts, rtscts)
+            self.assertEqual(self.s._rtscts, rtscts)
         # no illegal values here, normal rules for the boolean value of an
         # object are used thus all objects have a truth value.
 
@@ -161,17 +161,17 @@ class Test_ChangeAttributes(unittest.TestCase):
     # now, already sets a port
     def disabled_test_UnconfiguredPort(self):
         # an unconfigured port cannot be opened
-        self.failUnlessRaises(serial.SerialException, self.s.open)
+        self.assertRaises(serial.SerialException, self.s.open)
 
     def test_PortOpenClose(self):
         self.s.port = PORT
         for i in range(3):
             # open the port and check flag
-            self.failUnless(not self.s.isOpen())
+            self.assertTrue(not self.s.isOpen())
             self.s.open()
-            self.failUnless(self.s.isOpen())
+            self.assertTrue(self.s.isOpen())
             self.s.close()
-            self.failUnless(not self.s.isOpen())
+            self.assertTrue(not self.s.isOpen())
 
 
 if __name__ == '__main__':
diff --git a/test/test_high_load.py b/test/test_high_load.py
index a51c5e8..0138039 100644
--- a/test/test_high_load.py
+++ b/test/test_high_load.py
@@ -52,8 +52,8 @@ class TestHighLoad(unittest.TestCase):
         for i in range(self.N):
             q = bytes_0to255
             self.s.write(q)
-            self.failUnlessEqual(self.s.read(len(q)), q) # expected same which was written before
-        self.failUnlessEqual(self.s.inWaiting(), 0) # expected empty buffer after all sent chars are read
+            self.assertEqual(self.s.read(len(q)), q) # expected same which was written before
+        self.assertEqual(self.s.inWaiting(), 0) # expected empty buffer after all sent chars are read
 
     def test1_WriteWriteReadLoopback(self):
         """Send big strings, multiple write one read."""
@@ -61,8 +61,8 @@ class TestHighLoad(unittest.TestCase):
         for i in range(self.N):
             self.s.write(q)
         read = self.s.read(len(q)*self.N)
-        self.failUnlessEqual(read, q*self.N, "expected what was written before. got %d bytes, expected %d" % (len(read), self.N*len(q)))
-        self.failUnlessEqual(self.s.inWaiting(), 0) # "expected empty buffer after all sent chars are read")
+        self.assertEqual(read, q*self.N, "expected what was written before. got %d bytes, expected %d" % (len(read), self.N*len(q)))
+        self.assertEqual(self.s.inWaiting(), 0) # "expected empty buffer after all sent chars are read")
 
 
 if __name__ == '__main__':
diff --git a/test/test_iolib.py b/test/test_iolib.py
index 7f30a49..43ab797 100644
--- a/test/test_iolib.py
+++ b/test/test_iolib.py
@@ -64,7 +64,7 @@ class Test_SerialAndIO(unittest.TestCase):
         self.io.write(b"hello\n".decode('utf-8'))
         self.io.flush() # it is buffering. required to get the data out
         hello = self.io.readline()
-        self.failUnlessEqual(hello, b"hello\n".decode('utf-8'))
+        self.assertEqual(hello, b"hello\n".decode('utf-8'))
 
 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 if __name__ == '__main__':
diff --git a/test/test_readline.py b/test/test_readline.py
index 61381f4..1456ac9 100644
--- a/test/test_readline.py
+++ b/test/test_readline.py
@@ -52,16 +52,16 @@ class Test_Readline(unittest.TestCase):
     def test_readline(self):
         """Test readline method"""
         self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a]))
-        self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x31, 0x0a]))
-        self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x32, 0x0a]))
-        self.failUnlessEqual(self.s.readline(), serial.to_bytes([0x33, 0x0a]))
+        self.assertEqual(self.s.readline(), serial.to_bytes([0x31, 0x0a]))
+        self.assertEqual(self.s.readline(), serial.to_bytes([0x32, 0x0a]))
+        self.assertEqual(self.s.readline(), serial.to_bytes([0x33, 0x0a]))
         # this time we will get a timeout
-        self.failUnlessEqual(self.s.readline(), serial.to_bytes([]))
+        self.assertEqual(self.s.readline(), serial.to_bytes([]))
 
     def test_readlines(self):
         """Test readlines method"""
         self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a]))
-        self.failUnlessEqual(
+        self.assertEqual(
                 self.s.readlines(),
                 [serial.to_bytes([0x31, 0x0a]), serial.to_bytes([0x32, 0x0a]), serial.to_bytes([0x33, 0x0a])]
                 )
@@ -70,7 +70,7 @@ class Test_Readline(unittest.TestCase):
         """Test xreadlines method (skipped for io based systems)"""
         if hasattr(self.s, 'xreadlines'):
             self.s.write(serial.to_bytes([0x31, 0x0a, 0x32, 0x0a, 0x33, 0x0a]))
-            self.failUnlessEqual(
+            self.assertEqual(
                     list(self.s.xreadlines()),
                     [serial.to_bytes([0x31, 0x0a]), serial.to_bytes([0x32, 0x0a]), serial.to_bytes([0x33, 0x0a])]
                     )
@@ -81,7 +81,7 @@ class Test_Readline(unittest.TestCase):
         lines = []
         for line in self.s:
             lines.append(line)
-        self.failUnlessEqual(
+        self.assertEqual(
                 lines,
                 [serial.to_bytes([0x31, 0x0a]), serial.to_bytes([0x32, 0x0a]), serial.to_bytes([0x33, 0x0a])]
                 )
@@ -90,7 +90,7 @@ class Test_Readline(unittest.TestCase):
         """Test readline with alternative eol settings (skipped for io based systems)"""
         if hasattr(self.s, 'xreadlines'): # test if it is our FileLike base class
             self.s.write(serial.to_bytes("no\rno\nyes\r\n"))
-            self.failUnlessEqual(
+            self.assertEqual(
                     self.s.readline(eol=serial.to_bytes("\r\n")),
                     serial.to_bytes("no\rno\nyes\r\n"))
 
diff --git a/test/test_rfc2217.py b/test/test_rfc2217.py
index 7fd9a6e..132a1ca 100644
--- a/test/test_rfc2217.py
+++ b/test/test_rfc2217.py
@@ -18,12 +18,12 @@ class Test_RFC2217(unittest.TestCase):
     def test_failed_connection(self):
         # connection to closed port
         s = serial.serial_for_url('rfc2217://127.99.99.99:2217', do_not_open=True)
-        self.failUnlessRaises(serial.SerialException, s.open)
+        self.assertRaises(serial.SerialException, s.open)
         self.assertFalse(s.is_open)
         s.close() # no errors expected
         # invalid address
         s = serial.serial_for_url('rfc2217://127goingtofail', do_not_open=True)
-        self.failUnlessRaises(serial.SerialException, s.open)
+        self.assertRaises(serial.SerialException, s.open)
         self.assertFalse(s.is_open)
         s.close() # no errors expected
         # close w/o open is also OK
diff --git a/test/test_rs485.py b/test/test_rs485.py
index 01e318b..27c0740 100644
--- a/test/test_rs485.py
+++ b/test/test_rs485.py
@@ -28,14 +28,14 @@ class Test_RS485_settings(unittest.TestCase):
     def test_enable_RS485(self):
         # XXX open() port - but will result in fail for most HW...
         #~ self.s.open()
-        self.failUnlessEqual(self.s._rs485_mode, None, 'RS485 is disabled by default')
-        self.failUnlessEqual(self.s.rs485_mode, None, 'RS485 is disabled by default')
+        self.assertEqual(self.s._rs485_mode, None, 'RS485 is disabled by default')
+        self.assertEqual(self.s.rs485_mode, None, 'RS485 is disabled by default')
         self.s.rs485_mode = serial.rs485.RS485Settings()
-        self.failUnless(self.s._rs485_mode is not None, 'RS485 is enabled')
-        self.failUnless(self.s.rs485_mode is not None, 'RS485 is enabled')
+        self.assertTrue(self.s._rs485_mode is not None, 'RS485 is enabled')
+        self.assertTrue(self.s.rs485_mode is not None, 'RS485 is enabled')
         self.s.rs485_mode = None
-        self.failUnlessEqual(self.s._rs485_mode, None, 'RS485 is disabled again')
-        self.failUnlessEqual(self.s.rs485_mode, None, 'RS485 is disabled again')
+        self.assertEqual(self.s._rs485_mode, None, 'RS485 is disabled again')
+        self.assertEqual(self.s.rs485_mode, None, 'RS485 is disabled again')
 
 
 class Test_RS485_class(unittest.TestCase):
@@ -50,7 +50,7 @@ class Test_RS485_class(unittest.TestCase):
     def test_RS485_class(self):
         self.s.rs485_mode = serial.rs485.RS485Settings()
         self.s.write(b'hello')
-        self.failUnlessEqual(self.s.read(5), b'hello')
+        self.assertEqual(self.s.read(5), b'hello')
 
 
 
diff --git a/test/test_settings_dict.py b/test/test_settings_dict.py
index e11d24f..935c8b6 100644
--- a/test/test_settings_dict.py
+++ b/test/test_settings_dict.py
@@ -30,7 +30,7 @@ class Test_SettingsDict(unittest.TestCase):
         ser = serial.serial_for_url(PORT, do_not_open=True)
         d = ser.get_settings()
         for setting in SETTINGS:
-            self.failUnlessEqual(getattr(ser, setting), d[setting])
+            self.assertEqual(getattr(ser, setting), d[setting])
 
     def test_partial_settings(self):
         """partial settings dictionaries are also accepted"""
@@ -40,7 +40,7 @@ class Test_SettingsDict(unittest.TestCase):
         del d['bytesize']
         ser.apply_settings(d)
         for setting in d:
-            self.failUnlessEqual(getattr(ser, setting), d[setting])
+            self.assertEqual(getattr(ser, setting), d[setting])
 
     def test_unknown_settings(self):
         """unknown settings are ignored"""
@@ -66,7 +66,7 @@ class Test_SettingsDict(unittest.TestCase):
             kwargs = {'do_not_open':True, setting:value}
             ser = serial.serial_for_url(PORT, **kwargs)
             d = ser.get_settings()
-            self.failUnlessEqual(getattr(ser, setting), value)
+            self.assertEqual(getattr(ser, setting), value)
 
 if __name__ == '__main__':
     import sys
diff --git a/test/test_url.py b/test/test_url.py
index 3f39cd0..926d2a8 100644
--- a/test/test_url.py
+++ b/test/test_url.py
@@ -29,12 +29,12 @@ class Test_URL(unittest.TestCase):
 
     def test_bad_url(self):
         """invalid protocol specified"""
-        self.failUnlessRaises(ValueError, serial.serial_for_url, "imnotknown://")
+        self.assertRaises(ValueError, serial.serial_for_url, "imnotknown://")
 
     def test_custom_url(self):
         """custom protocol handlers"""
         # it's unknown
-        self.failUnlessRaises(ValueError, serial.serial_for_url, "test://")
+        self.assertRaises(ValueError, serial.serial_for_url, "test://")
         # add search path
         serial.protocol_handler_packages.append('handlers')
         # now it should work
@@ -42,7 +42,7 @@ class Test_URL(unittest.TestCase):
         # remove our handler again
         serial.protocol_handler_packages.remove('handlers')
         # so it should not work anymore
-        self.failUnlessRaises(ValueError, serial.serial_for_url, "test://")
+        self.assertRaises(ValueError, serial.serial_for_url, "test://")
 
 
 if __name__ == '__main__':