def test_float_LOC(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.LOC,
u"30 30 0.000 N 100 30 0.000 W 10.00m 20m 2000m 20m")
- self.failUnless(rdata.float_latitude == 30.5)
- self.failUnless(rdata.float_longitude == -100.5)
+ self.assertTrue(rdata.float_latitude == 30.5)
+ self.assertTrue(rdata.float_longitude == -100.5)
def test_SOA_BIND8_TTL(self):
rdata1 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA,
u"a b 100 1s 1m 1h 1d")
rdata2 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.SOA,
u"a b 100 1 60 3600 86400")
- self.failUnless(rdata1 == rdata2)
+ self.assertTrue(rdata1 == rdata2)
def test_TTL_bounds_check(self):
def bad():
def test_empty_NSEC3_window(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NSEC3,
u"1 0 100 ABCD SCBCQHKU35969L2A68P3AD59LHF30715")
- self.failUnless(rdata.windows == [])
+ self.assertTrue(rdata.windows == [])
def test_zero_size_APL(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL,
"")
rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.APL,
"", 0, 0)
- self.failUnless(rdata == rdata2)
+ self.assertTrue(rdata == rdata2)
def test_CAA_from_wire(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CAA,
wire += b"trailing garbage"
rdata2 = dns.rdata.from_wire(dns.rdataclass.IN, dns.rdatatype.CAA,
wire, 0, rdlen)
- self.failUnless(rdata == rdata2)
+ self.assertTrue(rdata == rdata2)
def test_trailing_zero_APL(self):
in4 = "!1:127.0.0.0/1"
rd4 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, in4)
out4 = rd4.to_digestable(dns.name.from_text("test"))
text4 = binascii.hexlify(out4).decode('ascii')
- self.failUnless(text4 == '000101817f')
+ self.assertTrue(text4 == '000101817f')
in6 = "!2:::1000/1"
rd6 = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.APL, in6)
out6 = rd6.to_digestable(dns.name.from_text("test"))
text6 = binascii.hexlify(out6).decode('ascii')
- self.failUnless(text6 == '0002018f000000000000000000000000000010')
+ self.assertTrue(text6 == '0002018f000000000000000000000000000010')
def test_TXT_conversions(self):
t1 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT,
'foo')
t4 = dns.rdtypes.ANY.TXT.TXT(dns.rdataclass.IN, dns.rdatatype.TXT,
['foo'])
- self.failUnless(t1 == t2)
- self.failUnless(t1 == t2)
- self.failUnless(t1 == t4)
+ self.assertTrue(t1 == t2)
+ self.assertTrue(t1 == t2)
+ self.assertTrue(t1 == t4)
if __name__ == '__main__':
unittest.main()
def testMakeExampleSHA1DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA1')
- self.failUnless(ds == example_ds_sha1)
+ self.assertTrue(ds == example_ds_sha1)
def testMakeExampleSHA256DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256')
- self.failUnless(ds == example_ds_sha256)
+ self.assertTrue(ds == example_ds_sha256)
def testMakeSHA256DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256')
- self.failUnless(ds == good_ds)
+ self.assertTrue(ds == good_ds)
if __name__ == '__main__':
class FlagsTestCase(unittest.TestCase):
def test_rcode1(self):
- self.failUnless(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR)
+ self.assertTrue(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR)
def test_rcode2(self):
- self.failUnless(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR")
+ self.assertTrue(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR")
def test_rcode3(self):
- self.failUnless(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0))
+ self.assertTrue(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0))
def test_rcode4(self):
- self.failUnless(dns.rcode.to_flags(dns.rcode.BADVERS) == \
+ self.assertTrue(dns.rcode.to_flags(dns.rcode.BADVERS) == \
(0, 0x01000000))
def test_rcode6(self):
- self.failUnless(dns.rcode.from_flags(0, 0x01000000) == \
+ self.assertTrue(dns.rcode.from_flags(0, 0x01000000) == \
dns.rcode.BADVERS)
def test_rcode7(self):
- self.failUnless(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED)
+ self.assertTrue(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED)
def test_rcode8(self):
def bad():
self.failUnlessRaises(ValueError, bad)
def test_flags1(self):
- self.failUnless(dns.flags.from_text("RA RD AA QR") == \
+ self.assertTrue(dns.flags.from_text("RA RD AA QR") == \
dns.flags.QR|dns.flags.AA|dns.flags.RD|dns.flags.RA)
def test_flags2(self):
flags = dns.flags.QR|dns.flags.AA|dns.flags.RD|dns.flags.RA
- self.failUnless(dns.flags.to_text(flags) == "QR AA RD RA")
+ self.assertTrue(dns.flags.to_text(flags) == "QR AA RD RA")
if __name__ == '__main__':
'10.0.0.5'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testIterateAllRdatas3(self): # type: () -> None
z = dns.zone.from_text(example_text3, 'example.', relativize=True)
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.0.0.8'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate1(self): # type: () -> None
z = dns.zone.from_text(example_text4, 'example.', relativize=True)
l = list(z.iterate_rdatas())
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME,
'SERVER.FOOBAR.'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate3(self): # type: () -> None
z = dns.zone.from_text(example_text6, 'example.', relativize=True)
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.CNAME,
'SERVER.FOOBAR.'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate4(self): # type: () -> None
z = dns.zone.from_text(example_text7, 'example.', relativize=True)
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.10.16.0'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate6(self): # type: () -> None
z = dns.zone.from_text(example_text9, 'example.', relativize=True)
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.10.16.0'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate7(self): # type: () -> None
z = dns.zone.from_text(example_text10, 'example.', relativize=True)
'zlb2.oob'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testGenerate8(self): # type: () -> None
z = dns.zone.from_text(example_text11, 'example.', relativize=True)
'10.0.0.2'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
if __name__ == '__main__':
def test_comparison_eq1(self):
q1 = dns.message.from_text(query_text)
q2 = dns.message.from_text(query_text)
- self.failUnless(q1 == q2)
+ self.assertTrue(q1 == q2)
def test_comparison_ne1(self):
q1 = dns.message.from_text(query_text)
q2 = dns.message.from_text(query_text)
q2.id = 10
- self.failUnless(q1 != q2)
+ self.assertTrue(q1 != q2)
def test_comparison_ne2(self):
q1 = dns.message.from_text(query_text)
q2 = dns.message.from_text(query_text)
q2.question = []
- self.failUnless(q1 != q2)
+ self.assertTrue(q1 != q2)
def test_comparison_ne3(self):
q1 = dns.message.from_text(query_text)
- self.failUnless(q1 != 1)
+ self.assertTrue(q1 != 1)
def test_EDNS_to_wire1(self):
q = dns.message.from_text(query_text)
w = q.to_wire()
- self.failUnless(w == goodwire)
+ self.assertTrue(w == goodwire)
def test_EDNS_from_wire1(self):
m = dns.message.from_wire(goodwire)
def test_EDNS_to_wire2(self):
q = dns.message.from_text(query_text_2)
w = q.to_wire()
- self.failUnless(w == goodwire3)
+ self.assertTrue(w == goodwire3)
def test_EDNS_from_wire2(self):
m = dns.message.from_wire(goodwire3)
- self.failUnless(str(m) == query_text_2)
+ self.assertTrue(str(m) == query_text_2)
def test_TooBig(self):
def bad():
def test_answer1(self):
a = dns.message.from_text(answer_text)
wire = a.to_wire(want_shuffle=False)
- self.failUnless(wire == goodwire2)
+ self.assertTrue(wire == goodwire2)
def test_TrailingJunk(self):
def bad():
def test_ExtendedRcodeSetting(self):
m = dns.message.make_query('foo', 'A')
m.set_rcode(4095)
- self.failUnless(m.rcode() == 4095)
+ self.assertTrue(m.rcode() == 4095)
m.set_rcode(2)
- self.failUnless(m.rcode() == 2)
+ self.assertTrue(m.rcode() == 2)
def test_EDNSVersionCoherence(self):
m = dns.message.make_query('foo', 'A')
m.use_edns(1)
- self.failUnless((m.ednsflags >> 16) & 0xFF == 1)
+ self.assertTrue((m.ednsflags >> 16) & 0xFF == 1)
def test_SettingNoEDNSOptionsImpliesNoEDNS(self):
m = dns.message.make_query('foo', 'A')
- self.failUnless(m.edns == -1)
+ self.assertTrue(m.edns == -1)
def test_SettingEDNSFlagsImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', ednsflags=dns.flags.DO)
- self.failUnless(m.edns == 0)
+ self.assertTrue(m.edns == 0)
def test_SettingEDNSPayloadImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', payload=4096)
- self.failUnless(m.edns == 0)
+ self.assertTrue(m.edns == 0)
def test_SettingEDNSRequestPayloadImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', request_payload=4096)
- self.failUnless(m.edns == 0)
+ self.assertTrue(m.edns == 0)
def test_SettingOptionsImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', options=[])
- self.failUnless(m.edns == 0)
+ self.assertTrue(m.edns == 0)
def test_FindRRset(self):
a = dns.message.from_text(answer_text)
rrs1 = a.find_rrset(a.answer, n, dns.rdataclass.IN, dns.rdatatype.SOA)
rrs2 = a.find_rrset(dns.message.ANSWER, n, dns.rdataclass.IN,
dns.rdatatype.SOA)
- self.failUnless(rrs1 == rrs2)
+ self.assertTrue(rrs1 == rrs2)
def test_CleanTruncated(self):
def bad():
def testFromTextRel4(self):
n = dns.name.from_text('@', origin=None)
- self.failUnless(n == dns.name.empty)
+ self.assertTrue(n == dns.name.empty)
def testFromTextRel5(self):
n = dns.name.from_text('@', origin=self.origin)
- self.failUnless(n == self.origin)
+ self.assertTrue(n == self.origin)
def testFromTextAbs1(self):
n = dns.name.from_text('foo.bar.')
self.failUnlessRaises(TypeError, bad)
def testAbs1(self):
- self.failUnless(dns.name.root.is_absolute())
+ self.assertTrue(dns.name.root.is_absolute())
def testAbs2(self):
- self.failUnless(not dns.name.empty.is_absolute())
+ self.assertTrue(not dns.name.empty.is_absolute())
def testAbs3(self):
- self.failUnless(self.origin.is_absolute())
+ self.assertTrue(self.origin.is_absolute())
def testAbs4(self):
n = dns.name.from_text('foo', origin=None)
- self.failUnless(not n.is_absolute())
+ self.assertTrue(not n.is_absolute())
def testWild1(self):
n = dns.name.from_text('*.foo', origin=None)
- self.failUnless(n.is_wild())
+ self.assertTrue(n.is_wild())
def testWild2(self):
n = dns.name.from_text('*a.foo', origin=None)
- self.failUnless(not n.is_wild())
+ self.assertTrue(not n.is_wild())
def testWild3(self):
n = dns.name.from_text('a.*.foo', origin=None)
- self.failUnless(not n.is_wild())
+ self.assertTrue(not n.is_wild())
def testWild4(self):
- self.failUnless(not dns.name.root.is_wild())
+ self.assertTrue(not dns.name.root.is_wild())
def testWild5(self):
- self.failUnless(not dns.name.empty.is_wild())
+ self.assertTrue(not dns.name.empty.is_wild())
def testHash1(self):
n1 = dns.name.from_text('fOo.COM')
def testCompare1(self):
n1 = dns.name.from_text('a')
n2 = dns.name.from_text('b')
- self.failUnless(n1 < n2)
- self.failUnless(n2 > n1)
+ self.assertTrue(n1 < n2)
+ self.assertTrue(n2 > n1)
def testCompare2(self):
n1 = dns.name.from_text('')
n2 = dns.name.from_text('b')
- self.failUnless(n1 < n2)
- self.failUnless(n2 > n1)
+ self.assertTrue(n1 < n2)
+ self.assertTrue(n2 > n1)
def testCompare3(self):
- self.failUnless(dns.name.empty < dns.name.root)
- self.failUnless(dns.name.root > dns.name.empty)
+ self.assertTrue(dns.name.empty < dns.name.root)
+ self.assertTrue(dns.name.root > dns.name.empty)
def testCompare4(self):
- self.failUnless(dns.name.root != 1)
+ self.assertTrue(dns.name.root != 1)
def testSubdomain1(self):
- self.failUnless(not dns.name.empty.is_subdomain(dns.name.root))
+ self.assertTrue(not dns.name.empty.is_subdomain(dns.name.root))
def testSubdomain2(self):
- self.failUnless(not dns.name.root.is_subdomain(dns.name.empty))
+ self.assertTrue(not dns.name.root.is_subdomain(dns.name.empty))
def testSubdomain3(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(n.is_subdomain(self.origin))
+ self.assertTrue(n.is_subdomain(self.origin))
def testSubdomain4(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(n.is_subdomain(dns.name.root))
+ self.assertTrue(n.is_subdomain(dns.name.root))
def testSubdomain5(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(n.is_subdomain(n))
+ self.assertTrue(n.is_subdomain(n))
def testSuperdomain1(self):
- self.failUnless(not dns.name.empty.is_superdomain(dns.name.root))
+ self.assertTrue(not dns.name.empty.is_superdomain(dns.name.root))
def testSuperdomain2(self):
- self.failUnless(not dns.name.root.is_superdomain(dns.name.empty))
+ self.assertTrue(not dns.name.root.is_superdomain(dns.name.empty))
def testSuperdomain3(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(self.origin.is_superdomain(n))
+ self.assertTrue(self.origin.is_superdomain(n))
def testSuperdomain4(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(dns.name.root.is_superdomain(n))
+ self.assertTrue(dns.name.root.is_superdomain(n))
def testSuperdomain5(self):
n = dns.name.from_text('foo', origin=self.origin)
- self.failUnless(n.is_superdomain(n))
+ self.assertTrue(n.is_superdomain(n))
def testCanonicalize1(self):
n = dns.name.from_text('FOO.bar', origin=self.origin)
def testEmptyLabel3(self):
n = dns.name.Name(['b', ''])
- self.failUnless(n)
+ self.assertTrue(n)
def testLongLabel(self):
n = dns.name.Name(['a' * 63])
- self.failUnless(n)
+ self.assertTrue(n)
def testLabelTooLong(self):
def bad():
def testLongName(self):
n = dns.name.Name(['a' * 63, 'a' * 63, 'a' * 63, 'a' * 62])
- self.failUnless(n)
+ self.assertTrue(n)
def testNameTooLong(self):
def bad():
n2 = dns.name.Name(['c', 'd'])
e = dns.name.Name(['a', 'b', 'c', 'd'])
r = n1 + n2
- self.failUnless(r == e)
+ self.assertTrue(r == e)
def testConcat2(self):
n1 = dns.name.Name(['a', 'b'])
n2 = dns.name.Name([])
e = dns.name.Name(['a', 'b'])
r = n1 + n2
- self.failUnless(r == e)
+ self.assertTrue(r == e)
def testConcat3(self):
n1 = dns.name.Name([])
n2 = dns.name.Name(['a', 'b'])
e = dns.name.Name(['a', 'b'])
r = n1 + n2
- self.failUnless(r == e)
+ self.assertTrue(r == e)
def testConcat4(self):
n1 = dns.name.Name(['a', 'b', ''])
n2 = dns.name.Name([])
e = dns.name.Name(['a', 'b', ''])
r = n1 + n2
- self.failUnless(r == e)
+ self.assertTrue(r == e)
def testConcat5(self):
n1 = dns.name.Name(['a', 'b'])
n2 = dns.name.Name(['c', ''])
e = dns.name.Name(['a', 'b', 'c', ''])
r = n1 + n2
- self.failUnless(r == e)
+ self.assertTrue(r == e)
def testConcat6(self):
def bad():
n2 = dns.name.from_text('foo.BAR.')
d1 = n1.to_digestable()
d2 = n2.to_digestable()
- self.failUnless(d1 == d2)
+ self.assertTrue(d1 == d2)
def testDigestable3(self):
d = dns.name.root.to_digestable()
(prefix, suffix) = n.split(2)
ep = dns.name.from_text('foo', None)
es = dns.name.from_text('bar.', None)
- self.failUnless(prefix == ep and suffix == es)
+ self.assertTrue(prefix == ep and suffix == es)
def testSplit2(self):
n = dns.name.from_text('foo.bar.')
(prefix, suffix) = n.split(1)
ep = dns.name.from_text('foo.bar', None)
es = dns.name.from_text('.', None)
- self.failUnless(prefix == ep and suffix == es)
+ self.assertTrue(prefix == ep and suffix == es)
def testSplit3(self):
n = dns.name.from_text('foo.bar.')
(prefix, suffix) = n.split(0)
ep = dns.name.from_text('foo.bar.', None)
es = dns.name.from_text('', None)
- self.failUnless(prefix == ep and suffix == es)
+ self.assertTrue(prefix == ep and suffix == es)
def testSplit4(self):
n = dns.name.from_text('foo.bar.')
(prefix, suffix) = n.split(3)
ep = dns.name.from_text('', None)
es = dns.name.from_text('foo.bar.', None)
- self.failUnless(prefix == ep and suffix == es)
+ self.assertTrue(prefix == ep and suffix == es)
def testBadSplit1(self):
def bad():
n = dns.name.from_text('a.foo.bar.', None)
o = dns.name.from_text('bar.', None)
e = dns.name.from_text('a.foo', None)
- self.failUnless(n.relativize(o) == e)
+ self.assertTrue(n.relativize(o) == e)
def testRelativize2(self):
n = dns.name.from_text('a.foo.bar.', None)
o = n
e = dns.name.empty
- self.failUnless(n.relativize(o) == e)
+ self.assertTrue(n.relativize(o) == e)
def testRelativize3(self):
n = dns.name.from_text('a.foo.bar.', None)
o = dns.name.from_text('blaz.', None)
e = n
- self.failUnless(n.relativize(o) == e)
+ self.assertTrue(n.relativize(o) == e)
def testRelativize4(self):
n = dns.name.from_text('a.foo', None)
o = dns.name.root
e = n
- self.failUnless(n.relativize(o) == e)
+ self.assertTrue(n.relativize(o) == e)
def testDerelativize1(self):
n = dns.name.from_text('a.foo', None)
o = dns.name.from_text('bar.', None)
e = dns.name.from_text('a.foo.bar.', None)
- self.failUnless(n.derelativize(o) == e)
+ self.assertTrue(n.derelativize(o) == e)
def testDerelativize2(self):
n = dns.name.empty
o = dns.name.from_text('a.foo.bar.', None)
e = o
- self.failUnless(n.derelativize(o) == e)
+ self.assertTrue(n.derelativize(o) == e)
def testDerelativize3(self):
n = dns.name.from_text('a.foo.bar.', None)
o = dns.name.from_text('blaz.', None)
e = n
- self.failUnless(n.derelativize(o) == e)
+ self.assertTrue(n.derelativize(o) == e)
def testChooseRelativity1(self):
n = dns.name.from_text('a.foo.bar.', None)
o = dns.name.from_text('bar.', None)
e = dns.name.from_text('a.foo', None)
- self.failUnless(n.choose_relativity(o, True) == e)
+ self.assertTrue(n.choose_relativity(o, True) == e)
def testChooseRelativity2(self):
n = dns.name.from_text('a.foo.bar.', None)
o = dns.name.from_text('bar.', None)
e = n
- self.failUnless(n.choose_relativity(o, False) == e)
+ self.assertTrue(n.choose_relativity(o, False) == e)
def testChooseRelativity3(self):
n = dns.name.from_text('a.foo', None)
o = dns.name.from_text('bar.', None)
e = dns.name.from_text('a.foo.bar.', None)
- self.failUnless(n.choose_relativity(o, False) == e)
+ self.assertTrue(n.choose_relativity(o, False) == e)
def testChooseRelativity4(self):
n = dns.name.from_text('a.foo', None)
o = None
e = n
- self.failUnless(n.choose_relativity(o, True) == e)
+ self.assertTrue(n.choose_relativity(o, True) == e)
def testChooseRelativity5(self):
n = dns.name.from_text('a.foo', None)
o = None
e = n
- self.failUnless(n.choose_relativity(o, False) == e)
+ self.assertTrue(n.choose_relativity(o, False) == e)
def testChooseRelativity6(self):
n = dns.name.from_text('a.foo.', None)
o = None
e = n
- self.failUnless(n.choose_relativity(o, True) == e)
+ self.assertTrue(n.choose_relativity(o, True) == e)
def testChooseRelativity7(self):
n = dns.name.from_text('a.foo.', None)
o = None
e = n
- self.failUnless(n.choose_relativity(o, False) == e)
+ self.assertTrue(n.choose_relativity(o, False) == e)
def testFromWire1(self):
w = b'\x03foo\x00\xc0\x00'
en2 = en1
ecused1 = 5
ecused2 = 2
- self.failUnless(n1 == en1 and cused1 == ecused1 and \
+ self.assertTrue(n1 == en1 and cused1 == ecused1 and \
n2 == en2 and cused2 == ecused2)
def testFromWire2(self):
ecused1 = 5
ecused2 = 4
ecused3 = 4
- self.failUnless(n1 == en1 and cused1 == ecused1 and \
+ self.assertTrue(n1 == en1 and cused1 == ecused1 and \
n2 == en2 and cused2 == ecused2 and \
n3 == en3 and cused3 == ecused3)
def testParent1(self):
n = dns.name.from_text('foo.bar.')
- self.failUnless(n.parent() == dns.name.from_text('bar.'))
- self.failUnless(n.parent().parent() == dns.name.root)
+ self.assertTrue(n.parent() == dns.name.from_text('bar.'))
+ self.assertTrue(n.parent().parent() == dns.name.root)
def testParent2(self):
n = dns.name.from_text('foo.bar', None)
- self.failUnless(n.parent() == dns.name.from_text('bar', None))
- self.failUnless(n.parent().parent() == dns.name.empty)
+ self.assertTrue(n.parent() == dns.name.from_text('bar', None))
+ self.assertTrue(n.parent().parent() == dns.name.empty)
def testParent3(self):
def bad():
def testReverseIPv6MappedIpv4(self):
e = dns.name.from_text('1.0.0.127.in-addr.arpa.')
n = dns.reversename.from_address('::ffff:127.0.0.1')
- self.failUnless(e == n)
+ self.assertTrue(e == n)
def testBadReverseIPv4(self):
def bad():
text = '+1 650 555 1212'
e = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.')
n = dns.e164.from_e164(text)
- self.failUnless(n == e)
+ self.assertTrue(n == e)
def testEnumToE164(self):
n = dns.name.from_text('2.1.2.1.5.5.5.0.5.6.1.e164.arpa.')
self.rndict[n2] = 2
def testDepth(self):
- self.failUnless(self.ndict.max_depth == 3)
+ self.assertTrue(self.ndict.max_depth == 3)
def testLookup1(self):
k = dns.name.from_text('foo.bar.')
- self.failUnless(self.ndict[k] == 1)
+ self.assertTrue(self.ndict[k] == 1)
def testLookup2(self):
k = dns.name.from_text('foo.bar.')
- self.failUnless(self.ndict.get_deepest_match(k)[1] == 1)
+ self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1)
def testLookup3(self):
k = dns.name.from_text('a.b.c.foo.bar.')
- self.failUnless(self.ndict.get_deepest_match(k)[1] == 1)
+ self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1)
def testLookup4(self):
k = dns.name.from_text('a.b.c.bar.')
- self.failUnless(self.ndict.get_deepest_match(k)[1] == 2)
+ self.assertTrue(self.ndict.get_deepest_match(k)[1] == 2)
def testLookup5(self):
def bad():
self.ndict[dns.name.empty] = 100
n = dns.name.from_text('a.b.c.')
v = self.ndict.get_deepest_match(n)[1]
- self.failUnless(v == 100)
+ self.assertTrue(v == 100)
def testLookup8(self):
def bad():
self.failUnlessRaises(ValueError, bad)
def testRelDepth(self):
- self.failUnless(self.rndict.max_depth == 2)
+ self.assertTrue(self.rndict.max_depth == 2)
def testRelLookup1(self):
k = dns.name.from_text('foo.bar', None)
- self.failUnless(self.rndict[k] == 1)
+ self.assertTrue(self.rndict[k] == 1)
def testRelLookup2(self):
k = dns.name.from_text('foo.bar', None)
- self.failUnless(self.rndict.get_deepest_match(k)[1] == 1)
+ self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1)
def testRelLookup3(self):
k = dns.name.from_text('a.b.c.foo.bar', None)
- self.failUnless(self.rndict.get_deepest_match(k)[1] == 1)
+ self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1)
def testRelLookup4(self):
k = dns.name.from_text('a.b.c.bar', None)
- self.failUnless(self.rndict.get_deepest_match(k)[1] == 2)
+ self.assertTrue(self.rndict.get_deepest_match(k)[1] == 2)
def testRelLookup7(self):
self.rndict[dns.name.empty] = 100
n = dns.name.from_text('a.b.c', None)
v = self.rndict.get_deepest_match(n)[1]
- self.failUnless(v == 100)
+ self.assertTrue(v == 100)
if __name__ == '__main__':
unittest.main()
def test_aton1(self):
a = aton6('::')
- self.failUnless(a == b'\x00' * 16)
+ self.assertTrue(a == b'\x00' * 16)
def test_aton2(self):
a = aton6('::1')
- self.failUnless(a == b'\x00' * 15 + b'\x01')
+ self.assertTrue(a == b'\x00' * 15 + b'\x01')
def test_aton3(self):
a = aton6('::10.0.0.1')
- self.failUnless(a == b'\x00' * 12 + b'\x0a\x00\x00\x01')
+ self.assertTrue(a == b'\x00' * 12 + b'\x0a\x00\x00\x01')
def test_aton4(self):
a = aton6('abcd::dcba')
- self.failUnless(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
+ self.assertTrue(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
def test_aton5(self):
a = aton6('1:2:3:4:5:6:7:8')
t2 = '::ffff:127.0.0.1'
t3 = '1::ffff:127.0.0.1'
self.failIf(dns.ipv6.is_mapped(aton6(t1)))
- self.failUnless(dns.ipv6.is_mapped(aton6(t2)))
+ self.assertTrue(dns.ipv6.is_mapped(aton6(t2)))
self.failIf(dns.ipv6.is_mapped(aton6(t3)))
def test_is_multicast(self):
t6 = 'ff00::1'
self.failIf(dns.inet.is_multicast(t1))
self.failIf(dns.inet.is_multicast(t2))
- self.failUnless(dns.inet.is_multicast(t3))
- self.failUnless(dns.inet.is_multicast(t4))
+ self.assertTrue(dns.inet.is_multicast(t3))
+ self.assertTrue(dns.inet.is_multicast(t4))
self.failIf(dns.inet.is_multicast(t5))
- self.failUnless(dns.inet.is_multicast(t6))
+ self.assertTrue(dns.inet.is_multicast(t6))
if __name__ == '__main__':
unittest.main()
def test_str(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4")
- self.failUnless(rdata.address == "1.2.3.4")
+ self.assertTrue(rdata.address == "1.2.3.4")
def test_unicode(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, u"1.2.3.4")
- self.failUnless(rdata.address == "1.2.3.4")
+ self.assertTrue(rdata.address == "1.2.3.4")
def test_module_registration(self):
TTXT = 64001
dns.rdata.register_type(tests.ttxt_module, TTXT, 'TTXT')
rdata = dns.rdata.from_text(dns.rdataclass.IN, TTXT, 'hello world')
- self.failUnless(rdata.strings == [b'hello', b'world'])
- self.failUnless(dns.rdatatype.to_text(TTXT) == 'TTXT')
- self.failUnless(dns.rdatatype.from_text('TTXT') == TTXT)
+ self.assertTrue(rdata.strings == [b'hello', b'world'])
+ self.assertTrue(dns.rdatatype.to_text(TTXT) == 'TTXT')
+ self.assertTrue(dns.rdatatype.from_text('TTXT') == TTXT)
def test_module_reregistration(self):
def bad():
# Classes
def test_class_meta1(self):
- self.failUnless(dns.rdataclass.is_metaclass(dns.rdataclass.ANY))
+ self.assertTrue(dns.rdataclass.is_metaclass(dns.rdataclass.ANY))
def test_class_meta2(self):
- self.failUnless(not dns.rdataclass.is_metaclass(dns.rdataclass.IN))
+ self.assertTrue(not dns.rdataclass.is_metaclass(dns.rdataclass.IN))
def test_class_bytext1(self):
- self.failUnless(dns.rdataclass.from_text('IN') == dns.rdataclass.IN)
+ self.assertTrue(dns.rdataclass.from_text('IN') == dns.rdataclass.IN)
def test_class_bytext2(self):
- self.failUnless(dns.rdataclass.from_text('CLASS1') ==
+ self.assertTrue(dns.rdataclass.from_text('CLASS1') ==
dns.rdataclass.IN)
def test_class_bytext_bounds1(self):
- self.failUnless(dns.rdataclass.from_text('CLASS0') == 0)
- self.failUnless(dns.rdataclass.from_text('CLASS65535') == 65535)
+ self.assertTrue(dns.rdataclass.from_text('CLASS0') == 0)
+ self.assertTrue(dns.rdataclass.from_text('CLASS65535') == 65535)
def test_class_bytext_bounds2(self):
def bad():
self.failUnlessRaises(dns.rdataclass.UnknownRdataclass, bad)
def test_class_totext1(self):
- self.failUnless(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN')
+ self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN')
def test_class_totext2(self):
- self.failUnless(dns.rdataclass.to_text(999) == 'CLASS999')
+ self.assertTrue(dns.rdataclass.to_text(999) == 'CLASS999')
def test_class_totext_bounds1(self):
def bad():
# Types
def test_type_meta1(self):
- self.failUnless(dns.rdatatype.is_metatype(dns.rdatatype.ANY))
+ self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.ANY))
def test_type_meta2(self):
- self.failUnless(dns.rdatatype.is_metatype(dns.rdatatype.OPT))
+ self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.OPT))
def test_type_meta3(self):
- self.failUnless(not dns.rdatatype.is_metatype(dns.rdatatype.A))
+ self.assertTrue(not dns.rdatatype.is_metatype(dns.rdatatype.A))
def test_type_singleton1(self):
- self.failUnless(dns.rdatatype.is_singleton(dns.rdatatype.SOA))
+ self.assertTrue(dns.rdatatype.is_singleton(dns.rdatatype.SOA))
def test_type_singleton2(self):
- self.failUnless(not dns.rdatatype.is_singleton(dns.rdatatype.A))
+ self.assertTrue(not dns.rdatatype.is_singleton(dns.rdatatype.A))
def test_type_bytext1(self):
- self.failUnless(dns.rdatatype.from_text('A') == dns.rdatatype.A)
+ self.assertTrue(dns.rdatatype.from_text('A') == dns.rdatatype.A)
def test_type_bytext2(self):
- self.failUnless(dns.rdatatype.from_text('TYPE1') ==
+ self.assertTrue(dns.rdatatype.from_text('TYPE1') ==
dns.rdatatype.A)
def test_type_bytext_bounds1(self):
- self.failUnless(dns.rdatatype.from_text('TYPE0') == 0)
- self.failUnless(dns.rdatatype.from_text('TYPE65535') == 65535)
+ self.assertTrue(dns.rdatatype.from_text('TYPE0') == 0)
+ self.assertTrue(dns.rdatatype.from_text('TYPE65535') == 65535)
def test_type_bytext_bounds2(self):
def bad():
self.failUnlessRaises(dns.rdatatype.UnknownRdatatype, bad)
def test_type_totext1(self):
- self.failUnless(dns.rdatatype.to_text(dns.rdatatype.A) == 'A')
+ self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A')
def test_type_totext2(self):
- self.failUnless(dns.rdatatype.to_text(999) == 'TYPE999')
+ self.assertTrue(dns.rdatatype.to_text(999) == 'TYPE999')
def test_type_totext_bounds1(self):
def bad():
self.failUnlessRaises(ValueError, bad)
def test_type0_totext(self):
- self.failUnless(dns.rdatatype.to_text(0) == 'TYPE0')
+ self.assertTrue(dns.rdatatype.to_text(0) == 'TYPE0')
if __name__ == '__main__':
unittest.main()
good_s = set() #type: Set[str]
good_f = 0
from_flags = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(good_f)
- self.failUnless(from_flags == good_s,
+ self.assertTrue(from_flags == good_s,
'"{}" != "{}"'.format(from_flags, good_s))
from_set = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s)
- self.failUnless(from_set == good_f,
+ self.assertTrue(from_set == good_f,
'"0x{:x}" != "0x{:x}"'.format(from_set, good_f))
def testFlagsAll(self): # type: () -> None
good_s = {'SEP', 'REVOKE', 'ZONE'}
good_f = 0x181
from_flags = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(good_f)
- self.failUnless(from_flags == good_s,
+ self.assertTrue(from_flags == good_s,
'"{}" != "{}"'.format(from_flags, good_s))
from_text = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s)
- self.failUnless(from_text == good_f,
+ self.assertTrue(from_text == good_f,
'"0x{:x}" != "0x{:x}"'.format(from_text, good_f))
def testFlagsUnknownToText(self): # type: () -> None
'''Test that undefined flags are returned in hexadecimal notation.'''
unk_s = {'0x8000'}
flags_s = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(0x8000)
- self.failUnless(flags_s == unk_s, '"{}" != "{}"'.format(flags_s, unk_s))
+ self.assertTrue(flags_s == unk_s, '"{}" != "{}"'.format(flags_s, unk_s))
def testFlagsUnknownToFlags(self): # type: () -> None
'''Test that conversion from undefined mnemonic raises error.'''
rr = dns.rrset.from_text('foo', 300, 'IN', 'DNSKEY', '257 3 8 KEY=')[0]
rr_s = {'ZONE', 'SEP'}
flags_s = rr.flags_to_text_set()
- self.failUnless(flags_s == rr_s, '"{}" != "{}"'.format(flags_s, rr_s))
+ self.assertTrue(flags_s == rr_s, '"{}" != "{}"'.format(flags_s, rr_s))
if __name__ == '__main__':
r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc',
'49 11 42.400 N 16 36 29.600 E 227.64m '
'1.00m 10000.00m 10.00m')
- self.failUnless(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
def testEqual2(self):
'''Test default values for size, horizontal and vertical precision.'''
(16, 36, 29, 600, 1),
22764.0, # centimeters
100.0, 1000000.00, 1000.0) # centimeters
- self.failUnless(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
def testEqual3(self):
'''Test size, horizontal and vertical precision parsers: 100 cm == 1 m.
r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc',
'49 11 42.400 N 16 36 29.600 E 227.64m '
'2.00m 10.00m 2.00m')[0]
- self.failUnless(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
def testEqual4(self):
'''Test size, horizontal and vertical precision parsers without unit.
r2 = dns.rrset.from_text('FOO', 600, 'in', 'loc',
'49 11 42.400 N 16 36 29.600 E 227.64 '
'2 10 2')[0] # meters without explicit unit
- self.failUnless(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
if __name__ == '__main__':
unittest.main()
def testRead(self):
f = StringIO(resolv_conf)
r = dns.resolver.Resolver(f)
- self.failUnless(r.nameservers == ['10.0.0.1', '10.0.0.2'] and
+ self.assertTrue(r.nameservers == ['10.0.0.1', '10.0.0.2'] and
r.domain == dns.name.from_text('foo'))
def testCacheExpiration(self):
cache = dns.resolver.Cache()
cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer)
time.sleep(2)
- self.failUnless(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN))
+ self.assertTrue(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN))
is None)
def testCacheCleaning(self):
cache = dns.resolver.Cache(cleaning_interval=1.0)
cache.put((name, dns.rdatatype.A, dns.rdataclass.IN), answer)
time.sleep(2)
- self.failUnless(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN))
+ self.assertTrue(cache.get((name, dns.rdatatype.A, dns.rdataclass.IN))
is None)
def testIndexErrorOnEmptyRRsetAccess(self):
name = dns.name.from_text('www.dnspython.org.')
ezname = dns.name.from_text('dnspython.org.')
zname = dns.resolver.zone_for_name(name)
- self.failUnless(zname == ezname)
+ self.assertTrue(zname == ezname)
@unittest.skipIf(not _network_available, "Internet not reachable")
def testZoneForName2(self):
name = dns.name.from_text('a.b.www.dnspython.org.')
ezname = dns.name.from_text('dnspython.org.')
zname = dns.resolver.zone_for_name(name)
- self.failUnless(zname == ezname)
+ self.assertTrue(zname == ezname)
@unittest.skipIf(not _network_available, "Internet not reachable")
def testZoneForName3(self):
name = dns.name.from_text('dnspython.org.')
ezname = dns.name.from_text('dnspython.org.')
zname = dns.resolver.zone_for_name(name)
- self.failUnless(zname == ezname)
+ self.assertTrue(zname == ezname)
def testZoneForName4(self):
def bad():
for i in range(0, 5):
name = dns.name.from_text('example%d.' % i)
if i == 0:
- self.failUnless(cache.get((name, dns.rdatatype.A,
+ self.assertTrue(cache.get((name, dns.rdatatype.A,
dns.rdataclass.IN))
is None)
else:
- self.failUnless(not cache.get((name, dns.rdatatype.A,
+ self.assertTrue(not cache.get((name, dns.rdatatype.A,
dns.rdataclass.IN))
is None)
for i in range(0, 5):
name = dns.name.from_text('example%d.' % i)
if i == 1:
- self.failUnless(cache.get((name, dns.rdatatype.A,
+ self.assertTrue(cache.get((name, dns.rdatatype.A,
dns.rdataclass.IN))
is None)
else:
- self.failUnless(not cache.get((name, dns.rdatatype.A,
+ self.assertTrue(not cache.get((name, dns.rdatatype.A,
dns.rdataclass.IN))
is None)
time.sleep(2)
for i in range(0, 4):
name = dns.name.from_text('example%d.' % i)
- self.failUnless(cache.get((name, dns.rdatatype.A,
+ self.assertTrue(cache.get((name, dns.rdatatype.A,
dns.rdataclass.IN))
is None)
def testEqual1(self):
r1 = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1', '10.0.0.2')
r2 = dns.rrset.from_text('FOO', 300, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 == r2)
+ self.assertTrue(r1 == r2)
def testEqual2(self):
r1 = dns.rrset.from_text('foo', 300, 'in', 'a', '10.0.0.1', '10.0.0.2')
r2 = dns.rrset.from_text('FOO', 600, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 == r2)
+ self.assertTrue(r1 == r2)
def testNotEqual1(self):
r1 = dns.rrset.from_text('fooa', 30, 'in', 'a', '10.0.0.1', '10.0.0.2')
r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 != r2)
+ self.assertTrue(r1 != r2)
def testNotEqual2(self):
r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1', '10.0.0.3')
r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 != r2)
+ self.assertTrue(r1 != r2)
def testNotEqual3(self):
r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1', '10.0.0.2',
'10.0.0.3')
r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 != r2)
+ self.assertTrue(r1 != r2)
def testNotEqual4(self):
r1 = dns.rrset.from_text('foo', 30, 'in', 'a', '10.0.0.1')
r2 = dns.rrset.from_text('FOO', 30, 'in', 'a', '10.0.0.2', '10.0.0.1')
- self.failUnless(r1 != r2)
+ self.assertTrue(r1 != r2)
if __name__ == '__main__':
unittest.main()
def testLen1(self):
s1 = S()
- self.failUnless(len(s1) == 0)
+ self.assertTrue(len(s1) == 0)
def testLen2(self):
s1 = S([1, 2, 3])
- self.failUnless(len(s1) == 3)
+ self.assertTrue(len(s1) == 3)
def testLen3(self):
s1 = S([1, 2, 3, 3, 3])
- self.failUnless(len(s1) == 3)
+ self.assertTrue(len(s1) == 3)
def testUnion1(self):
s1 = S([1, 2, 3])
s2 = S([1, 2, 3])
e = S([1, 2, 3])
- self.failUnless(s1 | s2 == e)
+ self.assertTrue(s1 | s2 == e)
def testUnion2(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([1, 2, 3])
- self.failUnless(s1 | s2 == e)
+ self.assertTrue(s1 | s2 == e)
def testUnion3(self):
s1 = S([1, 2, 3])
s2 = S([3, 4])
e = S([1, 2, 3, 4])
- self.failUnless(s1 | s2 == e)
+ self.assertTrue(s1 | s2 == e)
def testIntersection1(self):
s1 = S([1, 2, 3])
s2 = S([1, 2, 3])
e = S([1, 2, 3])
- self.failUnless(s1 & s2 == e)
+ self.assertTrue(s1 & s2 == e)
def testIntersection2(self):
s1 = S([0, 1, 2, 3])
s2 = S([1, 2, 3, 4])
e = S([1, 2, 3])
- self.failUnless(s1 & s2 == e)
+ self.assertTrue(s1 & s2 == e)
def testIntersection3(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([])
- self.failUnless(s1 & s2 == e)
+ self.assertTrue(s1 & s2 == e)
def testIntersection4(self):
s1 = S([1, 2, 3])
s2 = S([5, 4])
e = S([])
- self.failUnless(s1 & s2 == e)
+ self.assertTrue(s1 & s2 == e)
def testDifference1(self):
s1 = S([1, 2, 3])
s2 = S([5, 4])
e = S([1, 2, 3])
- self.failUnless(s1 - s2 == e)
+ self.assertTrue(s1 - s2 == e)
def testDifference2(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([1, 2, 3])
- self.failUnless(s1 - s2 == e)
+ self.assertTrue(s1 - s2 == e)
def testDifference3(self):
s1 = S([1, 2, 3])
s2 = S([3, 2])
e = S([1])
- self.failUnless(s1 - s2 == e)
+ self.assertTrue(s1 - s2 == e)
def testDifference4(self):
s1 = S([1, 2, 3])
s2 = S([3, 2, 1])
e = S([])
- self.failUnless(s1 - s2 == e)
+ self.assertTrue(s1 - s2 == e)
def testSubset1(self):
s1 = S([1, 2, 3])
s2 = S([3, 2, 1])
- self.failUnless(s1.issubset(s2))
+ self.assertTrue(s1.issubset(s2))
def testSubset2(self):
s1 = S([1, 2, 3])
- self.failUnless(s1.issubset(s1))
+ self.assertTrue(s1.issubset(s1))
def testSubset3(self):
s1 = S([])
s2 = S([1, 2, 3])
- self.failUnless(s1.issubset(s2))
+ self.assertTrue(s1.issubset(s2))
def testSubset4(self):
s1 = S([1])
s2 = S([1, 2, 3])
- self.failUnless(s1.issubset(s2))
+ self.assertTrue(s1.issubset(s2))
def testSubset5(self):
s1 = S([])
s2 = S([])
- self.failUnless(s1.issubset(s2))
+ self.assertTrue(s1.issubset(s2))
def testSubset6(self):
s1 = S([1, 4])
s2 = S([1, 2, 3])
- self.failUnless(not s1.issubset(s2))
+ self.assertTrue(not s1.issubset(s2))
def testSuperset1(self):
s1 = S([1, 2, 3])
s2 = S([3, 2, 1])
- self.failUnless(s1.issuperset(s2))
+ self.assertTrue(s1.issuperset(s2))
def testSuperset2(self):
s1 = S([1, 2, 3])
- self.failUnless(s1.issuperset(s1))
+ self.assertTrue(s1.issuperset(s1))
def testSuperset3(self):
s1 = S([1, 2, 3])
s2 = S([])
- self.failUnless(s1.issuperset(s2))
+ self.assertTrue(s1.issuperset(s2))
def testSuperset4(self):
s1 = S([1, 2, 3])
s2 = S([1])
- self.failUnless(s1.issuperset(s2))
+ self.assertTrue(s1.issuperset(s2))
def testSuperset5(self):
s1 = S([])
s2 = S([])
- self.failUnless(s1.issuperset(s2))
+ self.assertTrue(s1.issuperset(s2))
def testSuperset6(self):
s1 = S([1, 2, 3])
s2 = S([1, 4])
- self.failUnless(not s1.issuperset(s2))
+ self.assertTrue(not s1.issuperset(s2))
def testUpdate1(self):
s1 = S([1, 2, 3])
u = (4, 5, 6)
e = S([1, 2, 3, 4, 5, 6])
s1.update(u)
- self.failUnless(s1 == e)
+ self.assertTrue(s1 == e)
def testUpdate2(self):
s1 = S([1, 2, 3])
u = []
e = S([1, 2, 3])
s1.update(u)
- self.failUnless(s1 == e)
+ self.assertTrue(s1 == e)
def testGetitem(self):
s1 = S([1, 2, 3])
i1 = s1[1]
i2 = s1[2]
s2 = S([i0, i1, i2])
- self.failUnless(s1 == s2)
+ self.assertTrue(s1 == s2)
def testGetslice(self):
s1 = S([1, 2, 3])
slice = s1[0:2]
- self.failUnless(len(slice) == 2)
+ self.assertTrue(len(slice) == 2)
item = s1[2]
slice.append(item)
s2 = S(slice)
- self.failUnless(s1 == s2)
+ self.assertTrue(s1 == s2)
def testDelitem(self):
s1 = S([1, 2, 3])
del s1[0]
i1 = s1[0]
i2 = s1[1]
- self.failUnless(i1 != i2)
- self.failUnless(i1 == 1 or i1 == 2 or i1 == 3)
- self.failUnless(i2 == 1 or i2 == 2 or i2 == 3)
+ self.assertTrue(i1 != i2)
+ self.assertTrue(i1 == 1 or i1 == 2 or i1 == 3)
+ self.assertTrue(i2 == 1 or i2 == 2 or i2 == 3)
def testDelslice(self):
s1 = S([1, 2, 3])
del s1[0:2]
i1 = s1[0]
- self.failUnless(i1 == 1 or i1 == 2 or i1 == 3)
+ self.assertTrue(i1 == 1 or i1 == 2 or i1 == 3)
if __name__ == '__main__':
unittest.main()
def testStr(self):
tok = dns.tokenizer.Tokenizer('foo')
token = tok.get()
- self.failUnless(token == Token(dns.tokenizer.IDENTIFIER, 'foo'))
+ self.assertTrue(token == Token(dns.tokenizer.IDENTIFIER, 'foo'))
def testQuotedString1(self):
tok = dns.tokenizer.Tokenizer(r'"foo"')
token = tok.get()
- self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, 'foo'))
+ self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo'))
def testQuotedString2(self):
tok = dns.tokenizer.Tokenizer(r'""')
token = tok.get()
- self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, ''))
+ self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, ''))
def testQuotedString3(self):
tok = dns.tokenizer.Tokenizer(r'"\"foo\""')
token = tok.get()
- self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"'))
+ self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"'))
def testQuotedString4(self):
tok = dns.tokenizer.Tokenizer(r'"foo\010bar"')
token = tok.get()
- self.failUnless(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar'))
+ self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar'))
def testQuotedString5(self):
def bad():
def testEmpty1(self):
tok = dns.tokenizer.Tokenizer('')
token = tok.get()
- self.failUnless(token.is_eof())
+ self.assertTrue(token.is_eof())
def testEmpty2(self):
tok = dns.tokenizer.Tokenizer('')
token1 = tok.get()
token2 = tok.get()
- self.failUnless(token1.is_eof() and token2.is_eof())
+ self.assertTrue(token1.is_eof() and token2.is_eof())
def testEOL(self):
tok = dns.tokenizer.Tokenizer('\n')
token1 = tok.get()
token2 = tok.get()
- self.failUnless(token1.is_eol() and token2.is_eof())
+ self.assertTrue(token1.is_eol() and token2.is_eof())
def testWS1(self):
tok = dns.tokenizer.Tokenizer(' \n')
token1 = tok.get()
- self.failUnless(token1.is_eol())
+ self.assertTrue(token1.is_eol())
def testWS2(self):
tok = dns.tokenizer.Tokenizer(' \n')
token1 = tok.get(want_leading=True)
- self.failUnless(token1.is_whitespace())
+ self.assertTrue(token1.is_whitespace())
def testComment1(self):
tok = dns.tokenizer.Tokenizer(' ;foo\n')
token1 = tok.get()
- self.failUnless(token1.is_eol())
+ self.assertTrue(token1.is_eol())
def testComment2(self):
tok = dns.tokenizer.Tokenizer(' ;foo\n')
token1 = tok.get(want_comment=True)
token2 = tok.get()
- self.failUnless(token1 == Token(dns.tokenizer.COMMENT, 'foo') and
+ self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo') and
token2.is_eol())
def testComment3(self):
tok = dns.tokenizer.Tokenizer(' ;foo bar\n')
token1 = tok.get(want_comment=True)
token2 = tok.get()
- self.failUnless(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and
+ self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and
token2.is_eol())
def testMultiline1(self):
tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)')
tokens = list(iter(tok))
- self.failUnless(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
+ self.assertTrue(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
Token(dns.tokenizer.IDENTIFIER, 'bar')])
def testMultiline2(self):
tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)\n')
tokens = list(iter(tok))
- self.failUnless(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
+ self.assertTrue(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
Token(dns.tokenizer.IDENTIFIER, 'bar'),
Token(dns.tokenizer.EOL, '\n')])
def testMultiline3(self):
t1 = tok.get()
tok.unget(t1)
t2 = tok.get()
- self.failUnless(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \
+ self.assertTrue(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \
t1.value == 'foo')
def testUnget2(self):
def testGetEOL1(self):
tok = dns.tokenizer.Tokenizer('\n')
t = tok.get_eol()
- self.failUnless(t == '\n')
+ self.assertTrue(t == '\n')
def testGetEOL2(self):
tok = dns.tokenizer.Tokenizer('')
t = tok.get_eol()
- self.failUnless(t == '')
+ self.assertTrue(t == '')
def testEscapedDelimiter1(self):
tok = dns.tokenizer.Tokenizer(r'ch\ ld')
t = tok.get()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld')
def testEscapedDelimiter2(self):
tok = dns.tokenizer.Tokenizer(r'ch\032ld')
t = tok.get()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld')
def testEscapedDelimiter3(self):
tok = dns.tokenizer.Tokenizer(r'ch\ild')
t = tok.get()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild')
def testEscapedDelimiter1u(self):
tok = dns.tokenizer.Tokenizer(r'ch\ ld')
t = tok.get().unescape()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld')
def testEscapedDelimiter2u(self):
tok = dns.tokenizer.Tokenizer(r'ch\032ld')
t = tok.get().unescape()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld')
def testEscapedDelimiter3u(self):
tok = dns.tokenizer.Tokenizer(r'ch\ild')
t = tok.get().unescape()
- self.failUnless(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child')
+ self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child')
if __name__ == '__main__':
unittest.main()
update.delete('bar', 'a', '10.0.0.4')
update.delete('blaz', 'a')
update.delete('blaz2')
- self.failUnless(update.to_wire() == goodwire)
+ self.assertTrue(update.to_wire() == goodwire)
def test_to_wire2(self): # type: () -> None
update = dns.update.Update('example')
update.delete('bar', 'a', '10.0.0.4')
update.delete('blaz', 'a')
update.delete('blaz2')
- self.failUnless(update.to_wire() == goodwire)
+ self.assertTrue(update.to_wire() == goodwire)
def test_to_wire3(self): # type: () -> None
update = dns.update.Update('example')
update.delete('bar', 'a', '10.0.0.4')
update.delete('blaz', 'a')
update.delete('blaz2')
- self.failUnless(update.to_wire() == goodwire)
+ self.assertTrue(update.to_wire() == goodwire)
def test_from_text1(self): # type: () -> None
update = dns.message.from_text(update_text)
w = update.to_wire(origin=dns.name.from_text('example'),
want_shuffle=False)
- self.failUnless(w == goodwire)
+ self.assertTrue(w == goodwire)
if __name__ == '__main__':
unittest.main()
finally:
if not _keep_output:
os.unlink(here('example1.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testFromFile2(self): # type: () -> None
z = dns.zone.from_file(here('example'), 'example', relativize=False)
finally:
if not _keep_output:
os.unlink(here('example2.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testToFileTextualStream(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
finally:
if not _keep_output:
os.unlink(here('example3-textual.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testToFileBinary(self): # type: () -> None
z = dns.zone.from_file(here('example'), 'example')
finally:
if not _keep_output:
os.unlink(here('example3-binary.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testToFileFilename(self): # type: () -> None
z = dns.zone.from_file(here('example'), 'example')
finally:
if not _keep_output:
os.unlink(here('example3-filename.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testToText(self): # type: () -> None
z = dns.zone.from_file(here('example'), 'example')
finally:
if not _keep_output:
os.unlink(here('example3.out'))
- self.failUnless(ok)
+ self.assertTrue(ok)
def testFromText(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rd2 = dns.rdata.from_wire(rds.rdclass, rds.rdtype,
wire, 0, len(wire),
origin=o)
- self.failUnless(rd == rd2)
+ self.assertTrue(rd == rd2)
def testEqual(self): # type: () -> None
z1 = dns.zone.from_text(example_text, 'example.', relativize=True)
z2 = dns.zone.from_text(example_text_output, 'example.',
relativize=True)
- self.failUnless(z1 == z2)
+ self.assertTrue(z1 == z2)
def testNotEqual1(self): # type: () -> None
z1 = dns.zone.from_text(example_text, 'example.', relativize=True)
z2 = dns.zone.from_text(something_quite_similar, 'example.',
relativize=True)
- self.failUnless(z1 != z2)
+ self.assertTrue(z1 != z2)
def testNotEqual2(self): # type: () -> None
z1 = dns.zone.from_text(example_text, 'example.', relativize=True)
z2 = dns.zone.from_text(something_different, 'example.',
relativize=True)
- self.failUnless(z1 != z2)
+ self.assertTrue(z1 != z2)
def testNotEqual3(self): # type: () -> None
z1 = dns.zone.from_text(example_text, 'example.', relativize=True)
z2 = dns.zone.from_text(something_different, 'example2.',
relativize=True)
- self.failUnless(z1 != z2)
+ self.assertTrue(z1 != z2)
def testFindRdataset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rds = z.find_rdataset('@', 'soa')
exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5')
- self.failUnless(rds == exrds)
+ self.assertTrue(rds == exrds)
def testFindRdataset2(self): # type: () -> None
def bad(): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rrs = z.find_rrset('@', 'soa')
exrrs = dns.rrset.from_text('@', 300, 'IN', 'SOA', 'foo bar 1 2 3 4 5')
- self.failUnless(rrs == exrrs)
+ self.assertTrue(rrs == exrrs)
def testFindRRset2(self): # type: () -> None
def bad(): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rds = z.get_rdataset('@', 'soa')
exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5')
- self.failUnless(rds == exrds)
+ self.assertTrue(rds == exrds)
def testGetRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rds = z.get_rdataset('@', 'loc')
- self.failUnless(rds is None)
+ self.assertTrue(rds is None)
def testGetRRset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rrs = z.get_rrset('@', 'soa')
exrrs = dns.rrset.from_text('@', 300, 'IN', 'SOA', 'foo bar 1 2 3 4 5')
- self.failUnless(rrs == exrrs)
+ self.assertTrue(rrs == exrrs)
def testGetRRset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rrs = z.get_rrset('@', 'loc')
- self.failUnless(rrs is None)
+ self.assertTrue(rrs is None)
def testReplaceRdataset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rdataset = dns.rdataset.from_text('in', 'ns', 300, 'ns3', 'ns4')
z.replace_rdataset('@', rdataset)
rds = z.get_rdataset('@', 'ns')
- self.failUnless(rds is rdataset)
+ self.assertTrue(rds is rdataset)
def testReplaceRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
rdataset = dns.rdataset.from_text('in', 'txt', 300, '"foo"')
z.replace_rdataset('@', rdataset)
rds = z.get_rdataset('@', 'txt')
- self.failUnless(rds is rdataset)
+ self.assertTrue(rds is rdataset)
def testDeleteRdataset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
z.delete_rdataset('@', 'ns')
rds = z.get_rdataset('@', 'ns')
- self.failUnless(rds is None)
+ self.assertTrue(rds is None)
def testDeleteRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
z.delete_rdataset('ns1', 'a')
node = z.get_node('ns1')
- self.failUnless(node is None)
+ self.assertTrue(node is None)
def testNodeFindRdataset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
node = z['@']
rds = node.find_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5')
- self.failUnless(rds == exrds)
+ self.assertTrue(rds == exrds)
def testNodeFindRdataset2(self): # type: () -> None
def bad(): # type: () -> None
node = z['@']
rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
exrds = dns.rdataset.from_text('IN', 'SOA', 300, 'foo bar 1 2 3 4 5')
- self.failUnless(rds == exrds)
+ self.assertTrue(rds == exrds)
def testNodeGetRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
node = z['@']
rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
- self.failUnless(rds is None)
+ self.assertTrue(rds is None)
def testNodeDeleteRdataset1(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
node = z['@']
node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
- self.failUnless(rds is None)
+ self.assertTrue(rds is None)
def testNodeDeleteRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
node = z['@']
node.delete_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
rds = node.get_rdataset(dns.rdataclass.IN, dns.rdatatype.LOC)
- self.failUnless(rds is None)
+ self.assertTrue(rds is None)
def testIterateRdatasets(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
ns = [n for n, r in z.iterate_rdatasets('A')]
ns.sort()
- self.failUnless(ns == [dns.name.from_text('ns1', None),
+ self.assertTrue(ns == [dns.name.from_text('ns1', None),
dns.name.from_text('ns2', None)])
def testIterateAllRdatasets(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
ns = [n for n, r in z.iterate_rdatasets()]
ns.sort()
- self.failUnless(ns == [dns.name.from_text('@', None),
+ self.assertTrue(ns == [dns.name.from_text('@', None),
dns.name.from_text('@', None),
dns.name.from_text('bar.foo', None),
dns.name.from_text('ns1', None),
3600,
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.0.0.2'))]
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testIterateAllRdatas(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.0.0.2'))]
exl.sort(key=_rdata_sort)
- self.failUnless(l == exl)
+ self.assertTrue(l == exl)
def testTTLs(self): # type: () -> None
z = dns.zone.from_text(ttl_example_text, 'example.', relativize=True)
n = z['@'] # type: dns.node.Node
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA))
- self.failUnless(rds.ttl == 3600)
+ self.assertTrue(rds.ttl == 3600)
n = z['ns1']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 86401)
+ self.assertTrue(rds.ttl == 86401)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 694861)
+ self.assertTrue(rds.ttl == 694861)
def testTTLFromSOA(self): # type: () -> None
z = dns.zone.from_text(ttl_from_soa_text, 'example.', relativize=True)
n = z['@']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.SOA))
- self.failUnless(rds.ttl == 3600)
+ self.assertTrue(rds.ttl == 3600)
soa_rd = rds[0]
n = z['ns1']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 694861)
+ self.assertTrue(rds.ttl == 694861)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == soa_rd.minimum)
+ self.assertTrue(rds.ttl == soa_rd.minimum)
def testTTLFromLast(self): # type: () -> None
z = dns.zone.from_text(ttl_from_last_text, 'example.', check_origin=False)
n = z['@']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.NS))
- self.failUnless(rds.ttl == 3600)
+ self.assertTrue(rds.ttl == 3600)
n = z['ns1']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 3600)
+ self.assertTrue(rds.ttl == 3600)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 694861)
+ self.assertTrue(rds.ttl == 694861)
def testNoTTL(self): # type: () -> None
def bad(): # type: () -> None
z1 = dns.zone.from_text(include_text, 'example.', relativize=True,
allow_include=True)
z2 = dns.zone.from_file(here('example'), 'example.', relativize=True)
- self.failUnless(z1 == z2)
+ self.assertTrue(z1 == z2)
def testBadDirective(self): # type: () -> None
def bad(): # type: () -> None
check_origin=False)
n = z['@']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.failUnless(rds.ttl == 300)
+ self.assertTrue(rds.ttl == 300)
def testZoneOrigin(self): # type: () -> None
z = dns.zone.Zone('example.')
- self.failUnless(z.origin == dns.name.from_text('example.'))
+ self.assertTrue(z.origin == dns.name.from_text('example.'))
def bad1(): # type: () -> None
o = dns.name.from_text('example', None)
dns.zone.Zone(o)
projects / thirdparty / dnspython.git / commitdiff
