TST: fix failUnlessRaises -> assertRaises deprecation

failUnlessRaises was deprecated in py31

14 files changed, 78 insertions, 78 deletions

diff --git a/tests/test_bugs.py b/tests/test_bugs.py
index e94e403..e7a3193 100644
--- a/tests/test_bugs.py
+++ b/tests/test_bugs.py
@@ -44,7 +44,7 @@ class BugsTestCase(unittest.TestCase):
     def test_TTL_bounds_check(self):
         def bad():
             dns.ttl.from_text("2147483648")
-        self.failUnlessRaises(dns.ttl.BadTTL, bad)
+        self.assertRaises(dns.ttl.BadTTL, bad)
 
     def test_empty_NSEC3_window(self):
         rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3,
diff --git a/tests/test_dnssec.py b/tests/test_dnssec.py
index d581f9a..2449210 100644
--- a/tests/test_dnssec.py
+++ b/tests/test_dnssec.py
@@ -164,7 +164,7 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         def bad():  # type: () -> None
             dns.dnssec.validate(abs_other_soa, abs_soa_rrsig, abs_keys, None,
                                 when)
-        self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
+        self.assertRaises(dns.dnssec.ValidationFailure, bad)
 
     def testRelativeRSAGood(self):  # type: () -> None
         dns.dnssec.validate(rel_soa, rel_soa_rrsig, rel_keys,
@@ -174,7 +174,7 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         def bad():  # type: () -> None
             dns.dnssec.validate(rel_other_soa, rel_soa_rrsig, rel_keys,
                                 abs_dnspython_org, when)
-        self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
+        self.assertRaises(dns.dnssec.ValidationFailure, bad)
 
     def testAbsoluteDSAGood(self):  # type: () -> None
         dns.dnssec.validate(abs_dsa_soa, abs_dsa_soa_rrsig, abs_dsa_keys, None,
@@ -184,7 +184,7 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         def bad():  # type: () -> None
             dns.dnssec.validate(abs_other_dsa_soa, abs_dsa_soa_rrsig,
                                 abs_dsa_keys, None, when2)
-        self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
+        self.assertRaises(dns.dnssec.ValidationFailure, bad)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
@@ -198,7 +198,7 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         def bad():  # type: () -> None
             dns.dnssec.validate(abs_other_ecdsa256_soa, abs_ecdsa256_soa_rrsig,
                                 abs_ecdsa256_keys, None, when3)
-        self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
+        self.assertRaises(dns.dnssec.ValidationFailure, bad)
 
     @unittest.skipUnless(dns.dnssec._have_ecdsa,
                          "python ECDSA cannot be imported")
@@ -212,7 +212,7 @@ class DNSSECValidatorTestCase(unittest.TestCase):
         def bad():  # type: () -> None
             dns.dnssec.validate(abs_other_ecdsa384_soa, abs_ecdsa384_soa_rrsig,
                                 abs_ecdsa384_keys, None, when4)
-        self.failUnlessRaises(dns.dnssec.ValidationFailure, bad)
+        self.assertRaises(dns.dnssec.ValidationFailure, bad)
 
 
 class DNSSECMakeDSTestCase(unittest.TestCase):
diff --git a/tests/test_flags.py b/tests/test_flags.py
index 132869d..20c200d 100644
--- a/tests/test_flags.py
+++ b/tests/test_flags.py
@@ -46,7 +46,7 @@ class FlagsTestCase(unittest.TestCase):
     def test_rcode8(self):
         def bad():
             dns.rcode.to_flags(4096)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_flags1(self):
         self.assertTrue(dns.flags.from_text("RA RD AA QR") == \
diff --git a/tests/test_generate.py b/tests/test_generate.py
index d0ca19c..bcd116b 100644
--- a/tests/test_generate.py
+++ b/tests/test_generate.py
@@ -151,12 +151,12 @@ class GenerateTestCase(unittest.TestCase):
     def testFromText(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(example_text, 'example.', relativize=True)
-        self.failUnlessRaises(dns.zone.NoSOA, bad)
+        self.assertRaises(dns.zone.NoSOA, bad)
 
     def testFromText1(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(example_text1, 'example.', relativize=True)
-        self.failUnlessRaises(dns.zone.NoSOA, bad)
+        self.assertRaises(dns.zone.NoSOA, bad)
 
     def testIterateAllRdatas2(self): # type: () -> None
         z = dns.zone.from_text(example_text2, 'example.', relativize=True)
diff --git a/tests/test_message.py b/tests/test_message.py
index 8de668c..34512f0 100644
--- a/tests/test_message.py
+++ b/tests/test_message.py
@@ -142,7 +142,7 @@ class MessageTestCase(unittest.TestCase):
                                             '10.0.0.%d' % i)
                 q.additional.append(rrset)
             q.to_wire(max_size=512)
-        self.failUnlessRaises(dns.exception.TooBig, bad)
+        self.assertRaises(dns.exception.TooBig, bad)
 
     def test_answer1(self):
         a = dns.message.from_text(answer_text)
@@ -153,20 +153,20 @@ class MessageTestCase(unittest.TestCase):
         def bad():
             badwire = goodwire + b'\x00'
             dns.message.from_wire(badwire)
-        self.failUnlessRaises(dns.message.TrailingJunk, bad)
+        self.assertRaises(dns.message.TrailingJunk, bad)
 
     def test_ShortHeader(self):
         def bad():
             badwire = b'\x00' * 11
             dns.message.from_wire(badwire)
-        self.failUnlessRaises(dns.message.ShortHeader, bad)
+        self.assertRaises(dns.message.ShortHeader, bad)
 
     def test_RespondingToResponse(self):
         def bad():
             q = dns.message.make_query('foo', 'A')
             r1 = dns.message.make_response(q)
             dns.message.make_response(r1)
-        self.failUnlessRaises(dns.exception.FormError, bad)
+        self.assertRaises(dns.exception.FormError, bad)
 
     def test_ExtendedRcodeSetting(self):
         m = dns.message.make_query('foo', 'A')
@@ -214,7 +214,7 @@ class MessageTestCase(unittest.TestCase):
             a.flags |= dns.flags.TC
             wire = a.to_wire(want_shuffle=False)
             dns.message.from_wire(wire)
-        self.failUnlessRaises(dns.message.Truncated, bad)
+        self.assertRaises(dns.message.Truncated, bad)
 
     def test_MessyTruncated(self):
         def bad():
@@ -222,7 +222,7 @@ class MessageTestCase(unittest.TestCase):
             a.flags |= dns.flags.TC
             wire = a.to_wire(want_shuffle=False)
             dns.message.from_wire(wire[:-3])
-        self.failUnlessRaises(dns.message.Truncated, bad)
+        self.assertRaises(dns.message.Truncated, bad)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_name.py b/tests/test_name.py
index ccbc532..8a02015 100644
--- a/tests/test_name.py
+++ b/tests/test_name.py
@@ -101,12 +101,12 @@ class NameTestCase(unittest.TestCase):
     def testImmutable1(self):
         def bad():
             self.origin.labels = ()
-        self.failUnlessRaises(TypeError, bad)
+        self.assertRaises(TypeError, bad)
 
     def testImmutable2(self):
         def bad():
             self.origin.labels[0] = 'foo'
-        self.failUnlessRaises(TypeError, bad)
+        self.assertRaises(TypeError, bad)
 
     def testAbs1(self):
         self.assertTrue(dns.name.root.is_absolute())
@@ -290,12 +290,12 @@ class NameTestCase(unittest.TestCase):
     def testEmptyLabel1(self):
         def bad():
             dns.name.Name(['a', '', 'b'])
-        self.failUnlessRaises(dns.name.EmptyLabel, bad)
+        self.assertRaises(dns.name.EmptyLabel, bad)
 
     def testEmptyLabel2(self):
         def bad():
             dns.name.Name(['', 'b'])
-        self.failUnlessRaises(dns.name.EmptyLabel, bad)
+        self.assertRaises(dns.name.EmptyLabel, bad)
 
     def testEmptyLabel3(self):
         n = dns.name.Name(['b', ''])
@@ -308,7 +308,7 @@ class NameTestCase(unittest.TestCase):
     def testLabelTooLong(self):
         def bad():
             dns.name.Name(['a' * 64, 'b'])
-        self.failUnlessRaises(dns.name.LabelTooLong, bad)
+        self.assertRaises(dns.name.LabelTooLong, bad)
 
     def testLongName(self):
         n = dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 62])
@@ -317,7 +317,7 @@ class NameTestCase(unittest.TestCase):
     def testNameTooLong(self):
         def bad():
             dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 63])
-        self.failUnlessRaises(dns.name.NameTooLong, bad)
+        self.assertRaises(dns.name.NameTooLong, bad)
 
     def testConcat1(self):
         n1 = dns.name.Name(['a', 'b'])
@@ -359,13 +359,13 @@ class NameTestCase(unittest.TestCase):
             n1 = dns.name.Name(['a', 'b', ''])
             n2 = dns.name.Name(['c'])
             return n1 + n2
-        self.failUnlessRaises(dns.name.AbsoluteConcatenation, bad)
+        self.assertRaises(dns.name.AbsoluteConcatenation, bad)
 
     def testBadEscape(self):
         def bad():
             n = dns.name.from_text(r'a.b\0q1.c.')
             print(n)
-        self.failUnlessRaises(dns.name.BadEscape, bad)
+        self.assertRaises(dns.name.BadEscape, bad)
 
     def testDigestable1(self):
         n = dns.name.from_text('FOO.bar')
@@ -392,7 +392,7 @@ class NameTestCase(unittest.TestCase):
         def bad():
             n = dns.name.from_text('FOO.bar', None)
             n.to_digestable()
-        self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
+        self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
 
     def testToWire1(self):
         n = dns.name.from_text('FOO.bar')
@@ -448,7 +448,7 @@ class NameTestCase(unittest.TestCase):
             f = BytesIO()
             compress = {} # type: Dict[dns.name.Name,int]
             n.to_wire(f, compress)
-        self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
+        self.assertRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
 
     def testSplit1(self):
         n = dns.name.from_text('foo.bar.')
@@ -482,13 +482,13 @@ class NameTestCase(unittest.TestCase):
         def bad():
             n = dns.name.from_text('foo.bar.')
             n.split(-1)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def testBadSplit2(self):
         def bad():
             n = dns.name.from_text('foo.bar.')
             n.split(4)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def testRelativize1(self):
         n = dns.name.from_text('a.foo.bar.', None)
@@ -607,25 +607,25 @@ class NameTestCase(unittest.TestCase):
         def bad():
             w = b'\x03foo\xc0\x04'
             dns.name.from_wire(w, 0)
-        self.failUnlessRaises(dns.name.BadPointer, bad)
+        self.assertRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire2(self):
         def bad():
             w = b'\x03foo\xc0\x05'
             dns.name.from_wire(w, 0)
-        self.failUnlessRaises(dns.name.BadPointer, bad)
+        self.assertRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire3(self):
         def bad():
             w = b'\xbffoo'
             dns.name.from_wire(w, 0)
-        self.failUnlessRaises(dns.name.BadLabelType, bad)
+        self.assertRaises(dns.name.BadLabelType, bad)
 
     def testBadFromWire4(self):
         def bad():
             w = b'\x41foo'
             dns.name.from_wire(w, 0)
-        self.failUnlessRaises(dns.name.BadLabelType, bad)
+        self.assertRaises(dns.name.BadLabelType, bad)
 
     def testParent1(self):
         n = dns.name.from_text('foo.bar.')
@@ -641,13 +641,13 @@ class NameTestCase(unittest.TestCase):
         def bad():
             n = dns.name.root
             n.parent()
-        self.failUnlessRaises(dns.name.NoParent, bad)
+        self.assertRaises(dns.name.NoParent, bad)
 
     def testParent4(self):
         def bad():
             n = dns.name.empty
             n.parent()
-        self.failUnlessRaises(dns.name.NoParent, bad)
+        self.assertRaises(dns.name.NoParent, bad)
 
     def testFromUnicode1(self):
         n = dns.name.from_text('foo.bar')
@@ -701,7 +701,7 @@ class NameTestCase(unittest.TestCase):
             def bad():
                 codec = dns.name.IDNA_2008_Strict
                 return dns.name.from_unicode(t, idna_codec=codec)
-            self.failUnlessRaises(dns.name.IDNAException, bad)
+            self.assertRaises(dns.name.IDNAException, bad)
             e1 = dns.name.from_unicode(t, idna_codec=dns.name.IDNA_2008)
             self.assertEqual(str(e1), 'xn--knigsgchen-b4a3dun.')
             c2 = dns.name.IDNA_2008_Transitional
@@ -725,9 +725,9 @@ class NameTestCase(unittest.TestCase):
             def bad3():
                 codec = dns.name.IDNA_2008_Transitional
                 return dns.name.from_unicode(t, idna_codec=codec)
-            self.failUnlessRaises(dns.name.IDNAException, bad1)
-            self.failUnlessRaises(dns.name.IDNAException, bad2)
-            self.failUnlessRaises(dns.name.IDNAException, bad3)
+            self.assertRaises(dns.name.IDNAException, bad1)
+            self.assertRaises(dns.name.IDNAException, bad2)
+            self.assertRaises(dns.name.IDNAException, bad3)
             e = dns.name.from_unicode(t,
                                       idna_codec=dns.name.IDNA_2008_Practical)
             self.assertEqual(str(e), '_sip._tcp.xn--knigsgchen-b4a3dun.')
@@ -768,7 +768,7 @@ class NameTestCase(unittest.TestCase):
         def bad():
             # This throws in IDNA2003 because it doesn't "round trip".
             n.to_unicode(idna_codec=dns.name.IDNA_2003_Strict)
-        self.failUnlessRaises(dns.name.IDNAException, bad)
+        self.assertRaises(dns.name.IDNAException, bad)
 
     def testReverseIPv4(self):
         e = dns.name.from_text('1.0.0.127.in-addr.arpa.')
@@ -788,12 +788,12 @@ class NameTestCase(unittest.TestCase):
     def testBadReverseIPv4(self):
         def bad():
             dns.reversename.from_address('127.0.foo.1')
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testBadReverseIPv6(self):
         def bad():
             dns.reversename.from_address('::1::1')
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testForwardIPv4(self):
         n = dns.name.from_text('1.0.0.127.in-addr.arpa.')
diff --git a/tests/test_namedict.py b/tests/test_namedict.py
index c671d6f..97a5252 100644
--- a/tests/test_namedict.py
+++ b/tests/test_namedict.py
@@ -57,12 +57,12 @@ class NameTestCase(unittest.TestCase):
         def bad():
             n = dns.name.from_text('a.b.c.')
             self.ndict.get_deepest_match(n)
-        self.failUnlessRaises(KeyError, bad)
+        self.assertRaises(KeyError, bad)
 
     def testLookup6(self):
         def bad():
             self.ndict.get_deepest_match(dns.name.empty)
-        self.failUnlessRaises(KeyError, bad)
+        self.assertRaises(KeyError, bad)
 
     def testLookup7(self):
         self.ndict[dns.name.empty] = 100
@@ -73,7 +73,7 @@ class NameTestCase(unittest.TestCase):
     def testLookup8(self):
         def bad():
             self.ndict['foo'] = 100
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def testRelDepth(self):
         self.assertTrue(self.rndict.max_depth == 2)
diff --git a/tests/test_ntoaaton.py b/tests/test_ntoaaton.py
index f345275..763c1be 100644
--- a/tests/test_ntoaaton.py
+++ b/tests/test_ntoaaton.py
@@ -61,17 +61,17 @@ class NtoAAtoNTestCase(unittest.TestCase):
     def test_bad_aton1(self):
         def bad():
             aton6('abcd:dcba')
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def test_bad_aton2(self):
         def bad():
             aton6('abcd::dcba::1')
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def test_bad_aton3(self):
         def bad():
             aton6('1:2:3:4:5:6:7:8:9')
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def test_aton6(self):
         a = aton6('::')
@@ -162,12 +162,12 @@ class NtoAAtoNTestCase(unittest.TestCase):
     def test_bad_ntoa1(self):
         def bad():
             ntoa6('')
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_bad_ntoa2(self):
         def bad():
             ntoa6('\x00' * 17)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_good_v4_aton(self):
         pairs = [('1.2.3.4', b'\x01\x02\x03\x04'),
@@ -186,7 +186,7 @@ class NtoAAtoNTestCase(unittest.TestCase):
             return bad
         for addr in v4_bad_addrs:
             print(addr)
-            self.failUnlessRaises(dns.exception.SyntaxError, make_bad(addr))
+            self.assertRaises(dns.exception.SyntaxError, make_bad(addr))
 
     def test_bad_v6_aton(self):
         addrs = ['+::0', '0::0::', '::0::', '1:2:3:4:5:6:7:8:9',
@@ -198,7 +198,7 @@ class NtoAAtoNTestCase(unittest.TestCase):
                 x = aton6(a)
             return bad
         for addr in addrs:
-            self.failUnlessRaises(dns.exception.SyntaxError, make_bad(addr))
+            self.assertRaises(dns.exception.SyntaxError, make_bad(addr))
 
     def test_rfc5952_section_4_2_2(self):
         addr = '2001:db8:0:1:1:1:1:1'
diff --git a/tests/test_rdata.py b/tests/test_rdata.py
index 4e3f49d..43e1a67 100644
--- a/tests/test_rdata.py
+++ b/tests/test_rdata.py
@@ -45,7 +45,7 @@ class RdataTestCase(unittest.TestCase):
         def bad():
             TTXTTWO = dns.rdatatype.TXT
             dns.rdata.register_type(tests.ttxt_module, TTXTTWO, 'TTXTTWO')
-        self.failUnlessRaises(dns.rdata.RdatatypeExists, bad)
+        self.assertRaises(dns.rdata.RdatatypeExists, bad)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_rdtypeandclass.py b/tests/test_rdtypeandclass.py
index b911c13..fd696d2 100644
--- a/tests/test_rdtypeandclass.py
+++ b/tests/test_rdtypeandclass.py
@@ -44,12 +44,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
     def test_class_bytext_bounds2(self):
         def bad():
             dns.rdataclass.from_text('CLASS65536')
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_class_bytext_unknown(self):
         def bad():
             dns.rdataclass.from_text('XXX')
-        self.failUnlessRaises(dns.rdataclass.UnknownRdataclass, bad)
+        self.assertRaises(dns.rdataclass.UnknownRdataclass, bad)
 
     def test_class_totext1(self):
         self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN')
@@ -60,12 +60,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
     def test_class_totext_bounds1(self):
         def bad():
             dns.rdataclass.to_text(-1)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_class_totext_bounds2(self):
         def bad():
             dns.rdataclass.to_text(65536)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     # Types
 
@@ -98,12 +98,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
     def test_type_bytext_bounds2(self):
         def bad():
             dns.rdatatype.from_text('TYPE65536')
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_type_bytext_unknown(self):
         def bad():
             dns.rdatatype.from_text('XXX')
-        self.failUnlessRaises(dns.rdatatype.UnknownRdatatype, bad)
+        self.assertRaises(dns.rdatatype.UnknownRdatatype, bad)
 
     def test_type_totext1(self):
         self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A')
@@ -114,12 +114,12 @@ class RdTypeAndClassTestCase(unittest.TestCase):
     def test_type_totext_bounds1(self):
         def bad():
             dns.rdatatype.to_text(-1)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_type_totext_bounds2(self):
         def bad():
             dns.rdatatype.to_text(65536)
-        self.failUnlessRaises(ValueError, bad)
+        self.assertRaises(ValueError, bad)
 
     def test_type0_totext(self):
         self.assertTrue(dns.rdatatype.to_text(0) == 'TYPE0')
diff --git a/tests/test_rdtypeanydnskey.py b/tests/test_rdtypeanydnskey.py
index 70f2e22..967facc 100644
--- a/tests/test_rdtypeanydnskey.py
+++ b/tests/test_rdtypeanydnskey.py
@@ -53,7 +53,7 @@ class RdtypeAnyDnskeyTestCase(unittest.TestCase):
 
     def testFlagsUnknownToFlags(self): # type: () -> None
         '''Test that conversion from undefined mnemonic raises error.'''
-        self.failUnlessRaises(NotImplementedError,
+        self.assertRaises(NotImplementedError,
                               dns.rdtypes.ANY.DNSKEY.flags_from_text_set,
                               (['0x8000']))
 
diff --git a/tests/test_resolver.py b/tests/test_resolver.py
index f15fdfd..1f78839 100644
--- a/tests/test_resolver.py
+++ b/tests/test_resolver.py
@@ -140,7 +140,7 @@ class BaseResolverTests(unittest.TestCase):
                                          dns.rdataclass.IN, message,
                                          False)
             return answer[0]
-        self.failUnlessRaises(IndexError, bad)
+        self.assertRaises(IndexError, bad)
 
     def testIndexErrorOnEmptyRRsetDelete(self):
         def bad():
@@ -150,7 +150,7 @@ class BaseResolverTests(unittest.TestCase):
                                          dns.rdataclass.IN, message,
                                          False)
             del answer[0]
-        self.failUnlessRaises(IndexError, bad)
+        self.assertRaises(IndexError, bad)
 
     @unittest.skipIf(not _network_available, "Internet not reachable")
     def testZoneForName1(self):
@@ -177,7 +177,7 @@ class BaseResolverTests(unittest.TestCase):
         def bad():
             name = dns.name.from_text('dnspython.org', None)
             dns.resolver.zone_for_name(name)
-        self.failUnlessRaises(dns.resolver.NotAbsolute, bad)
+        self.assertRaises(dns.resolver.NotAbsolute, bad)
 
     def testLRUReplace(self):
         cache = dns.resolver.LRUCache(4)
diff --git a/tests/test_tokenizer.py b/tests/test_tokenizer.py
index 0075fd0..630a095 100644
--- a/tests/test_tokenizer.py
+++ b/tests/test_tokenizer.py
@@ -53,19 +53,19 @@ class TokenizerTestCase(unittest.TestCase):
         def bad():
             tok = dns.tokenizer.Tokenizer(r'"foo')
             tok.get()
-        self.failUnlessRaises(dns.exception.UnexpectedEnd, bad)
+        self.assertRaises(dns.exception.UnexpectedEnd, bad)
 
     def testQuotedString6(self):
         def bad():
             tok = dns.tokenizer.Tokenizer(r'"foo\01')
             tok.get()
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testQuotedString7(self):
         def bad():
             tok = dns.tokenizer.Tokenizer('"foo\nbar"')
             tok.get()
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testEmpty1(self):
         tok = dns.tokenizer.Tokenizer('')
@@ -129,13 +129,13 @@ class TokenizerTestCase(unittest.TestCase):
         def bad():
             tok = dns.tokenizer.Tokenizer('foo)')
             list(iter(tok))
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testMultiline4(self):
         def bad():
             tok = dns.tokenizer.Tokenizer('((foo)')
             list(iter(tok))
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testUnget1(self):
         tok = dns.tokenizer.Tokenizer('foo')
@@ -151,7 +151,7 @@ class TokenizerTestCase(unittest.TestCase):
             t1 = tok.get()
             tok.unget(t1)
             tok.unget(t1)
-        self.failUnlessRaises(dns.tokenizer.UngetBufferFull, bad)
+        self.assertRaises(dns.tokenizer.UngetBufferFull, bad)
 
     def testGetEOL1(self):
         tok = dns.tokenizer.Tokenizer('\n')
diff --git a/tests/test_zone.py b/tests/test_zone.py
index 2893718..b26159b 100644
--- a/tests/test_zone.py
+++ b/tests/test_zone.py
@@ -294,7 +294,7 @@ class ZoneTestCase(unittest.TestCase):
         def bad(): # type: () -> None
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             z.find_rdataset('@', 'loc')
-        self.failUnlessRaises(KeyError, bad)
+        self.assertRaises(KeyError, bad)
 
     def testFindRRset1(self): # type: () -> None
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
@@ -306,7 +306,7 @@ class ZoneTestCase(unittest.TestCase):
         def bad(): # type: () -> None
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             z.find_rrset('@', 'loc')
-        self.failUnlessRaises(KeyError, bad)
+        self.assertRaises(KeyError, bad)
 
     def testGetRdataset1(self): # type: () -> None
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
@@ -368,7 +368,7 @@ class ZoneTestCase(unittest.TestCase):
             z = dns.zone.from_text(example_text, 'example.', relativize=True)
             node = z['@']
             node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
-        self.failUnlessRaises(KeyError, bad)
+        self.assertRaises(KeyError, bad)
 
     def testNodeGetRdataset1(self): # type: () -> None
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
@@ -499,17 +499,17 @@ class ZoneTestCase(unittest.TestCase):
     def testNoTTL(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(no_ttl_text, 'example.', check_origin=False)
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testNoSOA(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(no_soa_text, 'example.', relativize=True)
-        self.failUnlessRaises(dns.zone.NoSOA, bad)
+        self.assertRaises(dns.zone.NoSOA, bad)
 
     def testNoNS(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(no_ns_text, 'example.', relativize=True)
-        self.failUnlessRaises(dns.zone.NoNS, bad)
+        self.assertRaises(dns.zone.NoNS, bad)
 
     def testInclude(self): # type: () -> None
         z1 = dns.zone.from_text(include_text, 'example.', relativize=True,
@@ -520,7 +520,7 @@ class ZoneTestCase(unittest.TestCase):
     def testBadDirective(self): # type: () -> None
         def bad(): # type: () -> None
             dns.zone.from_text(bad_directive_text, 'example.', relativize=True)
-        self.failUnlessRaises(dns.exception.SyntaxError, bad)
+        self.assertRaises(dns.exception.SyntaxError, bad)
 
     def testFirstRRStartsWithWhitespace(self): # type: () -> None
         # no name is specified, so default to the initial origin
@@ -536,10 +536,10 @@ class ZoneTestCase(unittest.TestCase):
         def bad1(): # type: () -> None
             o = dns.name.from_text('example', None)
             dns.zone.Zone(o)
-        self.failUnlessRaises(ValueError, bad1)
+        self.assertRaises(ValueError, bad1)
         def bad2(): # type: () -> None
             dns.zone.Zone(cast(str, 1.0))
-        self.failUnlessRaises(ValueError, bad2)
+        self.assertRaises(ValueError, bad2)
 
     def testZoneOriginNone(self): # type: () -> None
         dns.zone.Zone(cast(str, None))