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.assertTrue(rdata.float_latitude == 30.5)
- self.assertTrue(rdata.float_longitude == -100.5)
+ self.assertEqual(rdata.float_latitude, 30.5)
+ self.assertEqual(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.assertTrue(rdata1 == rdata2)
+ self.assertEqual(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.assertTrue(rdata.windows == [])
+ self.assertEqual(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.assertTrue(rdata == rdata2)
+ self.assertEqual(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.assertTrue(rdata == rdata2)
+ self.assertEqual(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.assertTrue(text4 == '000101817f')
+ self.assertEqual(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.assertTrue(text6 == '0002018f000000000000000000000000000010')
+ self.assertEqual(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.assertTrue(t1 == t2)
- self.assertTrue(t1 == t2)
- self.assertTrue(t1 == t4)
+ self.assertEqual(t1, t2)
+ self.assertEqual(t1, t2)
+ self.assertEqual(t1, t4)
if __name__ == '__main__':
unittest.main()
def testMakeExampleSHA1DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA1')
- self.assertTrue(ds == example_ds_sha1)
+ self.assertEqual(ds, example_ds_sha1)
def testMakeExampleSHA256DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_example, example_sep_key, 'SHA256')
- self.assertTrue(ds == example_ds_sha256)
+ self.assertEqual(ds, example_ds_sha256)
def testMakeSHA256DS(self): # type: () -> None
ds = dns.dnssec.make_ds(abs_dnspython_org, sep_key, 'SHA256')
- self.assertTrue(ds == good_ds)
+ self.assertEqual(ds, good_ds)
if __name__ == '__main__':
class FlagsTestCase(unittest.TestCase):
def test_rcode1(self):
- self.assertTrue(dns.rcode.from_text('FORMERR') == dns.rcode.FORMERR)
+ self.assertEqual(dns.rcode.from_text('FORMERR'), dns.rcode.FORMERR)
def test_rcode2(self):
- self.assertTrue(dns.rcode.to_text(dns.rcode.FORMERR) == "FORMERR")
+ self.assertEqual(dns.rcode.to_text(dns.rcode.FORMERR), "FORMERR")
def test_rcode3(self):
- self.assertTrue(dns.rcode.to_flags(dns.rcode.FORMERR) == (1, 0))
+ self.assertEqual(dns.rcode.to_flags(dns.rcode.FORMERR), (1, 0))
def test_rcode4(self):
- self.assertTrue(dns.rcode.to_flags(dns.rcode.BADVERS) == \
- (0, 0x01000000))
+ self.assertEqual(dns.rcode.to_flags(dns.rcode.BADVERS),
+ (0, 0x01000000))
def test_rcode6(self):
- self.assertTrue(dns.rcode.from_flags(0, 0x01000000) == \
- dns.rcode.BADVERS)
+ self.assertEqual(dns.rcode.from_flags(0, 0x01000000),
+ dns.rcode.BADVERS)
def test_rcode7(self):
- self.assertTrue(dns.rcode.from_flags(5, 0) == dns.rcode.REFUSED)
+ self.assertEqual(dns.rcode.from_flags(5, 0), dns.rcode.REFUSED)
def test_rcode8(self):
def bad():
self.assertRaises(ValueError, bad)
def test_flags1(self):
- self.assertTrue(dns.flags.from_text("RA RD AA QR") == \
- dns.flags.QR|dns.flags.AA|dns.flags.RD|dns.flags.RA)
+ self.assertEqual(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.assertTrue(dns.flags.to_text(flags) == "QR AA RD RA")
+ self.assertEqual(dns.flags.to_text(flags), "QR AA RD RA")
if __name__ == '__main__':
'10.0.0.5'))]
exl.sort(key=_rdata_sort)
- self.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(q1 == q2)
+ self.assertEqual(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.assertTrue(q1 != q2)
+ self.assertNotEqual(q1, q2)
def test_comparison_ne2(self):
q1 = dns.message.from_text(query_text)
q2 = dns.message.from_text(query_text)
q2.question = []
- self.assertTrue(q1 != q2)
+ self.assertNotEqual(q1, q2)
def test_comparison_ne3(self):
q1 = dns.message.from_text(query_text)
- self.assertTrue(q1 != 1)
+ self.assertNotEqual(q1, 1)
def test_EDNS_to_wire1(self):
q = dns.message.from_text(query_text)
w = q.to_wire()
- self.assertTrue(w == goodwire)
+ self.assertEqual(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.assertTrue(w == goodwire3)
+ self.assertEqual(w, goodwire3)
def test_EDNS_from_wire2(self):
m = dns.message.from_wire(goodwire3)
- self.assertTrue(str(m) == query_text_2)
+ self.assertEqual(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.assertTrue(wire == goodwire2)
+ self.assertEqual(wire, goodwire2)
def test_TrailingJunk(self):
def bad():
def test_ExtendedRcodeSetting(self):
m = dns.message.make_query('foo', 'A')
m.set_rcode(4095)
- self.assertTrue(m.rcode() == 4095)
+ self.assertEqual(m.rcode(), 4095)
m.set_rcode(2)
- self.assertTrue(m.rcode() == 2)
+ self.assertEqual(m.rcode(), 2)
def test_EDNSVersionCoherence(self):
m = dns.message.make_query('foo', 'A')
m.use_edns(1)
- self.assertTrue((m.ednsflags >> 16) & 0xFF == 1)
+ self.assertEqual((m.ednsflags >> 16) & 0xFF, 1)
def test_SettingNoEDNSOptionsImpliesNoEDNS(self):
m = dns.message.make_query('foo', 'A')
- self.assertTrue(m.edns == -1)
+ self.assertEqual(m.edns, -1)
def test_SettingEDNSFlagsImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', ednsflags=dns.flags.DO)
- self.assertTrue(m.edns == 0)
+ self.assertEqual(m.edns, 0)
def test_SettingEDNSPayloadImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', payload=4096)
- self.assertTrue(m.edns == 0)
+ self.assertEqual(m.edns, 0)
def test_SettingEDNSRequestPayloadImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', request_payload=4096)
- self.assertTrue(m.edns == 0)
+ self.assertEqual(m.edns, 0)
def test_SettingOptionsImpliesEDNS(self):
m = dns.message.make_query('foo', 'A', options=[])
- self.assertTrue(m.edns == 0)
+ self.assertEqual(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.assertTrue(rrs1 == rrs2)
+ self.assertEqual(rrs1, rrs2)
def test_CleanTruncated(self):
def bad():
def testFromTextRel4(self):
n = dns.name.from_text('@', origin=None)
- self.assertTrue(n == dns.name.empty)
+ self.assertEqual(n, dns.name.empty)
def testFromTextRel5(self):
n = dns.name.from_text('@', origin=self.origin)
- self.assertTrue(n == self.origin)
+ self.assertEqual(n, self.origin)
def testFromTextAbs1(self):
n = dns.name.from_text('foo.bar.')
self.assertTrue(dns.name.root.is_absolute())
def testAbs2(self):
- self.assertTrue(not dns.name.empty.is_absolute())
+ self.assertFalse(dns.name.empty.is_absolute())
def testAbs3(self):
self.assertTrue(self.origin.is_absolute())
def testAbs4(self):
n = dns.name.from_text('foo', origin=None)
- self.assertTrue(not n.is_absolute())
+ self.assertFalse(n.is_absolute())
def testWild1(self):
n = dns.name.from_text('*.foo', origin=None)
def testWild2(self):
n = dns.name.from_text('*a.foo', origin=None)
- self.assertTrue(not n.is_wild())
+ self.assertFalse(n.is_wild())
def testWild3(self):
n = dns.name.from_text('a.*.foo', origin=None)
- self.assertTrue(not n.is_wild())
+ self.assertFalse(n.is_wild())
def testWild4(self):
- self.assertTrue(not dns.name.root.is_wild())
+ self.assertFalse(dns.name.root.is_wild())
def testWild5(self):
- self.assertTrue(not dns.name.empty.is_wild())
+ self.assertFalse(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.assertTrue(n1 < n2)
- self.assertTrue(n2 > n1)
+ self.assertLess(n1, n2)
+ self.assertGreater(n2, n1)
def testCompare2(self):
n1 = dns.name.from_text('')
n2 = dns.name.from_text('b')
- self.assertTrue(n1 < n2)
- self.assertTrue(n2 > n1)
+ self.assertLess(n1, n2)
+ self.assertGreater(n2, n1)
def testCompare3(self):
- self.assertTrue(dns.name.empty < dns.name.root)
- self.assertTrue(dns.name.root > dns.name.empty)
+ self.assertLess(dns.name.empty, dns.name.root)
+ self.assertGreater(dns.name.root, dns.name.empty)
def testCompare4(self):
- self.assertTrue(dns.name.root != 1)
+ self.assertNotEqual(dns.name.root, 1)
def testSubdomain1(self):
- self.assertTrue(not dns.name.empty.is_subdomain(dns.name.root))
+ self.assertFalse(dns.name.empty.is_subdomain(dns.name.root))
def testSubdomain2(self):
- self.assertTrue(not dns.name.root.is_subdomain(dns.name.empty))
+ self.assertFalse(dns.name.root.is_subdomain(dns.name.empty))
def testSubdomain3(self):
n = dns.name.from_text('foo', origin=self.origin)
self.assertTrue(n.is_subdomain(n))
def testSuperdomain1(self):
- self.assertTrue(not dns.name.empty.is_superdomain(dns.name.root))
+ self.assertFalse(dns.name.empty.is_superdomain(dns.name.root))
def testSuperdomain2(self):
- self.assertTrue(not dns.name.root.is_superdomain(dns.name.empty))
+ self.assertFalse(dns.name.root.is_superdomain(dns.name.empty))
def testSuperdomain3(self):
n = dns.name.from_text('foo', origin=self.origin)
n2 = dns.name.Name(['c', 'd'])
e = dns.name.Name(['a', 'b', 'c', 'd'])
r = n1 + n2
- self.assertTrue(r == e)
+ self.assertEqual(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.assertTrue(r == e)
+ self.assertEqual(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.assertTrue(r == e)
+ self.assertEqual(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.assertTrue(r == e)
+ self.assertEqual(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.assertTrue(r == e)
+ self.assertEqual(r, e)
def testConcat6(self):
def bad():
n2 = dns.name.from_text('foo.BAR.')
d1 = n1.to_digestable()
d2 = n2.to_digestable()
- self.assertTrue(d1 == d2)
+ self.assertEqual(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.assertTrue(prefix == ep and suffix == es)
+ self.assertEqual(prefix, ep)
+ self.assertEqual(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.assertTrue(prefix == ep and suffix == es)
+ self.assertEqual(prefix, ep)
+ self.assertEqual(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.assertTrue(prefix == ep and suffix == es)
+ self.assertEqual(prefix, ep)
+ self.assertEqual(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.assertTrue(prefix == ep and suffix == es)
+ self.assertEqual(prefix, ep)
+ self.assertEqual(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.assertTrue(n.relativize(o) == e)
+ self.assertEqual(n.relativize(o), e)
def testRelativize2(self):
n = dns.name.from_text('a.foo.bar.', None)
o = n
e = dns.name.empty
- self.assertTrue(n.relativize(o) == e)
+ self.assertEqual(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.assertTrue(n.relativize(o) == e)
+ self.assertEqual(n.relativize(o), e)
def testRelativize4(self):
n = dns.name.from_text('a.foo', None)
o = dns.name.root
e = n
- self.assertTrue(n.relativize(o) == e)
+ self.assertEqual(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.assertTrue(n.derelativize(o) == e)
+ self.assertEqual(n.derelativize(o), e)
def testDerelativize2(self):
n = dns.name.empty
o = dns.name.from_text('a.foo.bar.', None)
e = o
- self.assertTrue(n.derelativize(o) == e)
+ self.assertEqual(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.assertTrue(n.derelativize(o) == e)
+ self.assertEqual(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.assertTrue(n.choose_relativity(o, True) == e)
+ self.assertEqual(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.assertTrue(n.choose_relativity(o, False) == e)
+ self.assertEqual(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.assertTrue(n.choose_relativity(o, False) == e)
+ self.assertEqual(n.choose_relativity(o, False), e)
def testChooseRelativity4(self):
n = dns.name.from_text('a.foo', None)
o = None
e = n
- self.assertTrue(n.choose_relativity(o, True) == e)
+ self.assertEqual(n.choose_relativity(o, True), e)
def testChooseRelativity5(self):
n = dns.name.from_text('a.foo', None)
o = None
e = n
- self.assertTrue(n.choose_relativity(o, False) == e)
+ self.assertEqual(n.choose_relativity(o, False), e)
def testChooseRelativity6(self):
n = dns.name.from_text('a.foo.', None)
o = None
e = n
- self.assertTrue(n.choose_relativity(o, True) == e)
+ self.assertEqual(n.choose_relativity(o, True), e)
def testChooseRelativity7(self):
n = dns.name.from_text('a.foo.', None)
o = None
e = n
- self.assertTrue(n.choose_relativity(o, False) == e)
+ self.assertEqual(n.choose_relativity(o, False), e)
def testFromWire1(self):
w = b'\x03foo\x00\xc0\x00'
en2 = en1
ecused1 = 5
ecused2 = 2
- self.assertTrue(n1 == en1 and cused1 == ecused1 and \
- n2 == en2 and cused2 == ecused2)
+ self.assertEqual(n1, en1)
+ self.assertEqual(cused1, ecused1)
+ self.assertEqual(n2, en2)
+ self.assertEqual(cused2, ecused2)
def testFromWire2(self):
w = b'\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05'
ecused1 = 5
ecused2 = 4
ecused3 = 4
- self.assertTrue(n1 == en1 and cused1 == ecused1 and \
- n2 == en2 and cused2 == ecused2 and \
- n3 == en3 and cused3 == ecused3)
+ self.assertEqual(n1, en1)
+ self.assertEqual(cused1, ecused1)
+ self.assertEqual(n2, en2)
+ self.assertEqual(cused2, ecused2)
+ self.assertEqual(n3, en3)
+ self.assertEqual(cused3, ecused3)
def testBadFromWire1(self):
def bad():
def testParent1(self):
n = dns.name.from_text('foo.bar.')
- self.assertTrue(n.parent() == dns.name.from_text('bar.'))
- self.assertTrue(n.parent().parent() == dns.name.root)
+ self.assertEqual(n.parent(), dns.name.from_text('bar.'))
+ self.assertEqual(n.parent().parent(), dns.name.root)
def testParent2(self):
n = dns.name.from_text('foo.bar', None)
- self.assertTrue(n.parent() == dns.name.from_text('bar', None))
- self.assertTrue(n.parent().parent() == dns.name.empty)
+ self.assertEqual(n.parent(), dns.name.from_text('bar', None))
+ self.assertEqual(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.assertTrue(e == n)
+ self.assertEqual(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.assertTrue(n == e)
+ self.assertEqual(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.assertTrue(self.ndict.max_depth == 3)
+ self.assertEqual(self.ndict.max_depth, 3)
def testLookup1(self):
k = dns.name.from_text('foo.bar.')
- self.assertTrue(self.ndict[k] == 1)
+ self.assertEqual(self.ndict[k], 1)
def testLookup2(self):
k = dns.name.from_text('foo.bar.')
- self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1)
+ self.assertEqual(self.ndict.get_deepest_match(k)[1], 1)
def testLookup3(self):
k = dns.name.from_text('a.b.c.foo.bar.')
- self.assertTrue(self.ndict.get_deepest_match(k)[1] == 1)
+ self.assertEqual(self.ndict.get_deepest_match(k)[1], 1)
def testLookup4(self):
k = dns.name.from_text('a.b.c.bar.')
- self.assertTrue(self.ndict.get_deepest_match(k)[1] == 2)
+ self.assertEqual(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.assertTrue(v == 100)
+ self.assertEqual(v, 100)
def testLookup8(self):
def bad():
self.assertRaises(ValueError, bad)
def testRelDepth(self):
- self.assertTrue(self.rndict.max_depth == 2)
+ self.assertEqual(self.rndict.max_depth, 2)
def testRelLookup1(self):
k = dns.name.from_text('foo.bar', None)
- self.assertTrue(self.rndict[k] == 1)
+ self.assertEqual(self.rndict[k] ,1)
def testRelLookup2(self):
k = dns.name.from_text('foo.bar', None)
- self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1)
+ self.assertEqual(self.rndict.get_deepest_match(k)[1], 1)
def testRelLookup3(self):
k = dns.name.from_text('a.b.c.foo.bar', None)
- self.assertTrue(self.rndict.get_deepest_match(k)[1] == 1)
+ self.assertEqual(self.rndict.get_deepest_match(k)[1], 1)
def testRelLookup4(self):
k = dns.name.from_text('a.b.c.bar', None)
- self.assertTrue(self.rndict.get_deepest_match(k)[1] == 2)
+ self.assertEqual(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.assertTrue(v == 100)
+ self.assertEqual(v, 100)
if __name__ == '__main__':
unittest.main()
def test_aton1(self):
a = aton6('::')
- self.assertTrue(a == b'\x00' * 16)
+ self.assertEqual(a, b'\x00' * 16)
def test_aton2(self):
a = aton6('::1')
- self.assertTrue(a == b'\x00' * 15 + b'\x01')
+ self.assertEqual(a, b'\x00' * 15 + b'\x01')
def test_aton3(self):
a = aton6('::10.0.0.1')
- self.assertTrue(a == b'\x00' * 12 + b'\x0a\x00\x00\x01')
+ self.assertEqual(a, b'\x00' * 12 + b'\x0a\x00\x00\x01')
def test_aton4(self):
a = aton6('abcd::dcba')
- self.assertTrue(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
+ self.assertEqual(a, b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
def test_aton5(self):
a = aton6('1:2:3:4:5:6:7:8')
def test_str(self):
rdata = dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A, "1.2.3.4")
- self.assertTrue(rdata.address == "1.2.3.4")
+ self.assertEqual(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.assertTrue(rdata.address == "1.2.3.4")
+ self.assertEqual(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.assertTrue(rdata.strings == [b'hello', b'world'])
- self.assertTrue(dns.rdatatype.to_text(TTXT) == 'TTXT')
- self.assertTrue(dns.rdatatype.from_text('TTXT') == TTXT)
+ self.assertEqual(rdata.strings, [b'hello', b'world'])
+ self.assertEqual(dns.rdatatype.to_text(TTXT), 'TTXT')
+ self.assertEqual(dns.rdatatype.from_text('TTXT'), TTXT)
def test_module_reregistration(self):
def bad():
self.assertTrue(dns.rdataclass.is_metaclass(dns.rdataclass.ANY))
def test_class_meta2(self):
- self.assertTrue(not dns.rdataclass.is_metaclass(dns.rdataclass.IN))
+ self.assertFalse(dns.rdataclass.is_metaclass(dns.rdataclass.IN))
def test_class_bytext1(self):
- self.assertTrue(dns.rdataclass.from_text('IN') == dns.rdataclass.IN)
+ self.assertEqual(dns.rdataclass.from_text('IN'), dns.rdataclass.IN)
def test_class_bytext2(self):
- self.assertTrue(dns.rdataclass.from_text('CLASS1') ==
- dns.rdataclass.IN)
+ self.assertEqual(dns.rdataclass.from_text('CLASS1'), dns.rdataclass.IN)
def test_class_bytext_bounds1(self):
- self.assertTrue(dns.rdataclass.from_text('CLASS0') == 0)
- self.assertTrue(dns.rdataclass.from_text('CLASS65535') == 65535)
+ self.assertEqual(dns.rdataclass.from_text('CLASS0'), 0)
+ self.assertEqual(dns.rdataclass.from_text('CLASS65535'), 65535)
def test_class_bytext_bounds2(self):
def bad():
self.assertRaises(dns.rdataclass.UnknownRdataclass, bad)
def test_class_totext1(self):
- self.assertTrue(dns.rdataclass.to_text(dns.rdataclass.IN) == 'IN')
+ self.assertEqual(dns.rdataclass.to_text(dns.rdataclass.IN), 'IN')
def test_class_totext2(self):
- self.assertTrue(dns.rdataclass.to_text(999) == 'CLASS999')
+ self.assertEqual(dns.rdataclass.to_text(999), 'CLASS999')
def test_class_totext_bounds1(self):
def bad():
self.assertTrue(dns.rdatatype.is_metatype(dns.rdatatype.OPT))
def test_type_meta3(self):
- self.assertTrue(not dns.rdatatype.is_metatype(dns.rdatatype.A))
+ self.assertFalse(dns.rdatatype.is_metatype(dns.rdatatype.A))
def test_type_singleton1(self):
self.assertTrue(dns.rdatatype.is_singleton(dns.rdatatype.SOA))
def test_type_singleton2(self):
- self.assertTrue(not dns.rdatatype.is_singleton(dns.rdatatype.A))
+ self.assertFalse(dns.rdatatype.is_singleton(dns.rdatatype.A))
def test_type_bytext1(self):
- self.assertTrue(dns.rdatatype.from_text('A') == dns.rdatatype.A)
+ self.assertEqual(dns.rdatatype.from_text('A'), dns.rdatatype.A)
def test_type_bytext2(self):
- self.assertTrue(dns.rdatatype.from_text('TYPE1') ==
- dns.rdatatype.A)
+ self.assertEqual(dns.rdatatype.from_text('TYPE1'), dns.rdatatype.A)
def test_type_bytext_bounds1(self):
- self.assertTrue(dns.rdatatype.from_text('TYPE0') == 0)
- self.assertTrue(dns.rdatatype.from_text('TYPE65535') == 65535)
+ self.assertEqual(dns.rdatatype.from_text('TYPE0'), 0)
+ self.assertEqual(dns.rdatatype.from_text('TYPE65535'), 65535)
def test_type_bytext_bounds2(self):
def bad():
self.assertRaises(dns.rdatatype.UnknownRdatatype, bad)
def test_type_totext1(self):
- self.assertTrue(dns.rdatatype.to_text(dns.rdatatype.A) == 'A')
+ self.assertEqual(dns.rdatatype.to_text(dns.rdatatype.A), 'A')
def test_type_totext2(self):
- self.assertTrue(dns.rdatatype.to_text(999) == 'TYPE999')
+ self.assertEqual(dns.rdatatype.to_text(999), 'TYPE999')
def test_type_totext_bounds1(self):
def bad():
self.assertRaises(ValueError, bad)
def test_type0_totext(self):
- self.assertTrue(dns.rdatatype.to_text(0) == 'TYPE0')
+ self.assertEqual(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.assertTrue(from_flags == good_s,
- '"{}" != "{}"'.format(from_flags, good_s))
+ self.assertEqual(from_flags, good_s,
+ '"{}" != "{}"'.format(from_flags, good_s))
from_set = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s)
- self.assertTrue(from_set == good_f,
- '"0x{:x}" != "0x{:x}"'.format(from_set, good_f))
+ self.assertEqual(from_set, good_f,
+ '"0x{:x}" != "0x{:x}"'.format(from_set, good_f))
def testFlagsAll(self): # type: () -> None
'''Test that all defined flags are recognized.'''
good_s = {'SEP', 'REVOKE', 'ZONE'}
good_f = 0x181
from_flags = dns.rdtypes.ANY.DNSKEY.flags_to_text_set(good_f)
- self.assertTrue(from_flags == good_s,
- '"{}" != "{}"'.format(from_flags, good_s))
+ self.assertEqual(from_flags, good_s,
+ '"{}" != "{}"'.format(from_flags, good_s))
from_text = dns.rdtypes.ANY.DNSKEY.flags_from_text_set(good_s)
- self.assertTrue(from_text == good_f,
- '"0x{:x}" != "0x{:x}"'.format(from_text, good_f))
+ self.assertEqual(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.assertTrue(flags_s == unk_s, '"{}" != "{}"'.format(flags_s, unk_s))
+ self.assertEqual(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.assertTrue(flags_s == rr_s, '"{}" != "{}"'.format(flags_s, rr_s))
+ self.assertEqual(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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertEqual(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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertEqual(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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertEqual(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.assertTrue(r1 == r2, '"{}" != "{}"'.format(r1, r2))
+ self.assertEqual(r1, r2, '"{}" != "{}"'.format(r1, r2))
if __name__ == '__main__':
unittest.main()
def testRead(self):
f = StringIO(resolv_conf)
r = dns.resolver.Resolver(f)
- self.assertTrue(r.nameservers == ['10.0.0.1', '10.0.0.2'] and
- r.domain == dns.name.from_text('foo'))
+ self.assertEqual(r.nameservers, ['10.0.0.1', '10.0.0.2'])
+ self.assertEqual(r.domain, dns.name.from_text('foo'))
def testCacheExpiration(self):
message = dns.message.from_text(message_text)
name = dns.name.from_text('www.dnspython.org.')
ezname = dns.name.from_text('dnspython.org.')
zname = dns.resolver.zone_for_name(name)
- self.assertTrue(zname == ezname)
+ self.assertEqual(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.assertTrue(zname == ezname)
+ self.assertEqual(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.assertTrue(zname == ezname)
+ self.assertEqual(zname, ezname)
def testZoneForName4(self):
def bad():
try:
raise dns.resolver.NXDOMAIN
except dns.exception.DNSException as e:
- self.assertTrue((e.args == (e.__doc__,)))
+ self.assertEqual(e.args, (e.__doc__,))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == e.__doc__), str(e))
+ self.assertEqual(str(e), e.__doc__, str(e))
self.assertTrue(('qnames' not in e.kwargs))
self.assertTrue(('responses' not in e.kwargs))
try:
raise dns.resolver.NXDOMAIN("errmsg")
except dns.exception.DNSException as e:
- self.assertTrue((e.args == ("errmsg",)))
+ self.assertEqual(e.args, ("errmsg",))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == "errmsg"), str(e))
+ self.assertEqual(str(e), "errmsg", str(e))
self.assertTrue(('qnames' not in e.kwargs))
self.assertTrue(('responses' not in e.kwargs))
try:
raise dns.resolver.NXDOMAIN("errmsg", -1)
except dns.exception.DNSException as e:
- self.assertTrue((e.args == ("errmsg", -1)))
+ self.assertEqual(e.args, ("errmsg", -1))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == "('errmsg', -1)"), str(e))
+ self.assertEqual(str(e), "('errmsg', -1)", str(e))
self.assertTrue(('qnames' not in e.kwargs))
self.assertTrue(('responses' not in e.kwargs))
raise dns.resolver.NXDOMAIN(qnames=[n1])
except dns.exception.DNSException as e:
MSG = "The DNS query name does not exist: a.b."
- self.assertTrue((e.args == (MSG,)), repr(e.args))
+ self.assertEqual(e.args, (MSG,), repr(e.args))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == MSG), str(e))
+ self.assertEqual(str(e), MSG, str(e))
self.assertTrue(('qnames' in e.kwargs))
- self.assertTrue((e.kwargs['qnames'] == [n1]))
+ self.assertEqual(e.kwargs['qnames'], [n1])
self.assertTrue(('responses' in e.kwargs))
- self.assertTrue((e.kwargs['responses'] == {}))
+ self.assertEqual(e.kwargs['responses'], {})
try:
raise dns.resolver.NXDOMAIN(qnames=[n2, n1])
e0 = dns.resolver.NXDOMAIN("errmsg")
e = e0 + e
MSG = "None of DNS query names exist: a.b.s., a.b."
- self.assertTrue((e.args == (MSG,)), repr(e.args))
+ self.assertEqual(e.args, (MSG,), repr(e.args))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == MSG), str(e))
+ self.assertEqual(str(e), MSG, str(e))
self.assertTrue(('qnames' in e.kwargs))
- self.assertTrue((e.kwargs['qnames'] == [n2, n1]))
+ self.assertEqual(e.kwargs['qnames'], [n2, n1])
self.assertTrue(('responses' in e.kwargs))
- self.assertTrue((e.kwargs['responses'] == {}))
+ self.assertEqual(e.kwargs['responses'], {})
try:
raise dns.resolver.NXDOMAIN(qnames=[n1], responses=['r1.1'])
raise dns.resolver.NXDOMAIN(qnames=[n1], responses={n1: 'r1.1'})
except dns.resolver.NXDOMAIN as e:
MSG = "The DNS query name does not exist: a.b."
- self.assertTrue((e.args == (MSG,)), repr(e.args))
+ self.assertEqual(e.args, (MSG,), repr(e.args))
self.assertTrue(('kwargs' in dir(e)))
- self.assertTrue((str(e) == MSG), str(e))
+ self.assertEqual(str(e), MSG, str(e))
self.assertTrue(('qnames' in e.kwargs))
- self.assertTrue((e.kwargs['qnames'] == [n1]))
+ self.assertEqual(e.kwargs['qnames'], [n1])
self.assertTrue(('responses' in e.kwargs))
- self.assertTrue((e.kwargs['responses'] == {n1: 'r1.1'}))
+ self.assertEqual(e.kwargs['responses'], {n1: 'r1.1'})
def test_nxdomain_merge(self):
n1 = dns.name.Name(('a', 'b', ''))
e2 = dns.resolver.NXDOMAIN(qnames=qnames2, responses=responses2)
e = e1 + e0 + e2
self.assertRaises(AttributeError, lambda: e0 + e0)
- self.assertTrue(e.kwargs['qnames'] == [n1, n4, n3], repr(e.kwargs['qnames']))
+ self.assertEqual(e.kwargs['qnames'], [n1, n4, n3],
+ repr(e.kwargs['qnames']))
self.assertTrue(e.kwargs['responses'][n1].startswith('r2.'))
self.assertTrue(e.kwargs['responses'][n2].startswith('r2.'))
self.assertTrue(e.kwargs['responses'][n3].startswith('r2.'))
e1 = dns.resolver.NXDOMAIN(qnames=[qname0, qname1, qname2], responses=responses)
e2 = dns.resolver.NXDOMAIN(qnames=[qname0, qname2, qname1], responses=responses)
self.assertRaises(TypeError, lambda: eX.canonical_name)
- self.assertTrue(e0.canonical_name == qname0)
- self.assertTrue(e1.canonical_name == dns.name.from_text(cname1))
- self.assertTrue(e2.canonical_name == dns.name.from_text(cname2))
+ self.assertEqual(e0.canonical_name, qname0)
+ self.assertEqual(e1.canonical_name, dns.name.from_text(cname1))
+ self.assertEqual(e2.canonical_name, dns.name.from_text(cname2))
class ResolverNameserverValidTypeTestCase(unittest.TestCase):
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.assertTrue(r1 == r2)
+ self.assertEqual(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.assertTrue(r1 == r2)
+ self.assertEqual(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.assertTrue(r1 != r2)
+ self.assertNotEqual(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.assertTrue(r1 != r2)
+ self.assertNotEqual(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.assertTrue(r1 != r2)
+ self.assertNotEqual(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.assertTrue(r1 != r2)
+ self.assertNotEqual(r1, r2)
if __name__ == '__main__':
unittest.main()
def testLen1(self):
s1 = S()
- self.assertTrue(len(s1) == 0)
+ self.assertEqual(len(s1), 0)
def testLen2(self):
s1 = S([1, 2, 3])
- self.assertTrue(len(s1) == 3)
+ self.assertEqual(len(s1), 3)
def testLen3(self):
s1 = S([1, 2, 3, 3, 3])
- self.assertTrue(len(s1) == 3)
+ self.assertEqual(len(s1), 3)
def testUnion1(self):
s1 = S([1, 2, 3])
s2 = S([1, 2, 3])
e = S([1, 2, 3])
- self.assertTrue(s1 | s2 == e)
+ self.assertEqual(s1 | s2, e)
def testUnion2(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([1, 2, 3])
- self.assertTrue(s1 | s2 == e)
+ self.assertEqual(s1 | s2, e)
def testUnion3(self):
s1 = S([1, 2, 3])
s2 = S([3, 4])
e = S([1, 2, 3, 4])
- self.assertTrue(s1 | s2 == e)
+ self.assertEqual(s1 | s2, e)
def testIntersection1(self):
s1 = S([1, 2, 3])
s2 = S([1, 2, 3])
e = S([1, 2, 3])
- self.assertTrue(s1 & s2 == e)
+ self.assertEqual(s1 & s2, e)
def testIntersection2(self):
s1 = S([0, 1, 2, 3])
s2 = S([1, 2, 3, 4])
e = S([1, 2, 3])
- self.assertTrue(s1 & s2 == e)
+ self.assertEqual(s1 & s2, e)
def testIntersection3(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([])
- self.assertTrue(s1 & s2 == e)
+ self.assertEqual(s1 & s2, e)
def testIntersection4(self):
s1 = S([1, 2, 3])
s2 = S([5, 4])
e = S([])
- self.assertTrue(s1 & s2 == e)
+ self.assertEqual(s1 & s2, e)
def testDifference1(self):
s1 = S([1, 2, 3])
s2 = S([5, 4])
e = S([1, 2, 3])
- self.assertTrue(s1 - s2 == e)
+ self.assertEqual(s1 - s2, e)
def testDifference2(self):
s1 = S([1, 2, 3])
s2 = S([])
e = S([1, 2, 3])
- self.assertTrue(s1 - s2 == e)
+ self.assertEqual(s1 - s2, e)
def testDifference3(self):
s1 = S([1, 2, 3])
s2 = S([3, 2])
e = S([1])
- self.assertTrue(s1 - s2 == e)
+ self.assertEqual(s1 - s2, e)
def testDifference4(self):
s1 = S([1, 2, 3])
s2 = S([3, 2, 1])
e = S([])
- self.assertTrue(s1 - s2 == e)
+ self.assertEqual(s1 - s2, e)
def testSubset1(self):
s1 = S([1, 2, 3])
u = (4, 5, 6)
e = S([1, 2, 3, 4, 5, 6])
s1.update(u)
- self.assertTrue(s1 == e)
+ self.assertEqual(s1, e)
def testUpdate2(self):
s1 = S([1, 2, 3])
u = []
e = S([1, 2, 3])
s1.update(u)
- self.assertTrue(s1 == e)
+ self.assertEqual(s1, e)
def testGetitem(self):
s1 = S([1, 2, 3])
i1 = s1[1]
i2 = s1[2]
s2 = S([i0, i1, i2])
- self.assertTrue(s1 == s2)
+ self.assertEqual(s1, s2)
def testGetslice(self):
s1 = S([1, 2, 3])
slice = s1[0:2]
- self.assertTrue(len(slice) == 2)
+ self.assertEqual(len(slice), 2)
item = s1[2]
slice.append(item)
s2 = S(slice)
- self.assertTrue(s1 == s2)
+ self.assertEqual(s1, s2)
def testDelitem(self):
s1 = S([1, 2, 3])
def testStr(self):
tok = dns.tokenizer.Tokenizer('foo')
token = tok.get()
- self.assertTrue(token == Token(dns.tokenizer.IDENTIFIER, 'foo'))
+ self.assertEqual(token, Token(dns.tokenizer.IDENTIFIER, 'foo'))
def testQuotedString1(self):
tok = dns.tokenizer.Tokenizer(r'"foo"')
token = tok.get()
- self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo'))
+ self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, 'foo'))
def testQuotedString2(self):
tok = dns.tokenizer.Tokenizer(r'""')
token = tok.get()
- self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, ''))
+ self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, ''))
def testQuotedString3(self):
tok = dns.tokenizer.Tokenizer(r'"\"foo\""')
token = tok.get()
- self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, '"foo"'))
+ self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, '"foo"'))
def testQuotedString4(self):
tok = dns.tokenizer.Tokenizer(r'"foo\010bar"')
token = tok.get()
- self.assertTrue(token == Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar'))
+ self.assertEqual(token, Token(dns.tokenizer.QUOTED_STRING, 'foo\x0abar'))
def testQuotedString5(self):
def bad():
tok = dns.tokenizer.Tokenizer(' ;foo\n')
token1 = tok.get(want_comment=True)
token2 = tok.get()
- self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo') and
- token2.is_eol())
+ self.assertEqual(token1, Token(dns.tokenizer.COMMENT, 'foo'))
+ self.assertTrue(token2.is_eol())
def testComment3(self):
tok = dns.tokenizer.Tokenizer(' ;foo bar\n')
token1 = tok.get(want_comment=True)
token2 = tok.get()
- self.assertTrue(token1 == Token(dns.tokenizer.COMMENT, 'foo bar') and
- token2.is_eol())
+ self.assertEqual(token1, Token(dns.tokenizer.COMMENT, 'foo bar'))
+ self.assertTrue(token2.is_eol())
def testMultiline1(self):
tok = dns.tokenizer.Tokenizer('( foo\n\n bar\n)')
tokens = list(iter(tok))
- self.assertTrue(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
- Token(dns.tokenizer.IDENTIFIER, 'bar')])
+ self.assertEqual(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.assertTrue(tokens == [Token(dns.tokenizer.IDENTIFIER, 'foo'),
- Token(dns.tokenizer.IDENTIFIER, 'bar'),
- Token(dns.tokenizer.EOL, '\n')])
+ self.assertEqual(tokens, [Token(dns.tokenizer.IDENTIFIER, 'foo'),
+ Token(dns.tokenizer.IDENTIFIER, 'bar'),
+ Token(dns.tokenizer.EOL, '\n')])
def testMultiline3(self):
def bad():
tok = dns.tokenizer.Tokenizer('foo)')
t1 = tok.get()
tok.unget(t1)
t2 = tok.get()
- self.assertTrue(t1 == t2 and t1.ttype == dns.tokenizer.IDENTIFIER and \
- t1.value == 'foo')
+ self.assertEqual(t1, t2)
+ self.assertEqual(t1.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t1.value, 'foo')
def testUnget2(self):
def bad():
def testGetEOL1(self):
tok = dns.tokenizer.Tokenizer('\n')
t = tok.get_eol()
- self.assertTrue(t == '\n')
+ self.assertEqual(t, '\n')
def testGetEOL2(self):
tok = dns.tokenizer.Tokenizer('')
t = tok.get_eol()
- self.assertTrue(t == '')
+ self.assertEqual(t, '')
def testEscapedDelimiter1(self):
tok = dns.tokenizer.Tokenizer(r'ch\ ld')
t = tok.get()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ ld')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t.value, r'ch\ ld')
def testEscapedDelimiter2(self):
tok = dns.tokenizer.Tokenizer(r'ch\032ld')
t = tok.get()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\032ld')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t.value, r'ch\032ld')
def testEscapedDelimiter3(self):
tok = dns.tokenizer.Tokenizer(r'ch\ild')
t = tok.get()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch\ild')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t.value, r'ch\ild')
def testEscapedDelimiter1u(self):
tok = dns.tokenizer.Tokenizer(r'ch\ ld')
t = tok.get().unescape()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'ch ld')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t.value, r'ch ld')
def testEscapedDelimiter2u(self):
tok = dns.tokenizer.Tokenizer(r'ch\032ld')
t = tok.get().unescape()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == 'ch ld')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(t.value, 'ch ld')
def testEscapedDelimiter3u(self):
tok = dns.tokenizer.Tokenizer(r'ch\ild')
t = tok.get().unescape()
- self.assertTrue(t.ttype == dns.tokenizer.IDENTIFIER and t.value == r'child')
+ self.assertEqual(t.ttype, dns.tokenizer.IDENTIFIER)
+ self.assertEqual(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.assertTrue(update.to_wire() == goodwire)
+ self.assertEqual(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.assertTrue(update.to_wire() == goodwire)
+ self.assertEqual(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.assertTrue(update.to_wire() == goodwire)
+ self.assertEqual(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.assertTrue(w == goodwire)
+ self.assertEqual(w, goodwire)
if __name__ == '__main__':
unittest.main()
rd2 = dns.rdata.from_wire(rds.rdclass, rds.rdtype,
wire, 0, len(wire),
origin=o)
- self.assertTrue(rd == rd2)
+ self.assertEqual(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.assertTrue(z1 == z2)
+ self.assertEqual(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.assertTrue(z1 != z2)
+ self.assertNotEqual(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.assertTrue(z1 != z2)
+ self.assertNotEqual(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.assertTrue(z1 != z2)
+ self.assertNotEqual(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.assertTrue(rds == exrds)
+ self.assertEqual(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.assertTrue(rrs == exrrs)
+ self.assertEqual(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.assertTrue(rds == exrds)
+ self.assertEqual(rds, exrds)
def testGetRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
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.assertTrue(rrs == exrrs)
+ self.assertEqual(rrs, exrrs)
def testGetRRset2(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.assertTrue(rds == exrds)
+ self.assertEqual(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.assertTrue(rds == exrds)
+ self.assertEqual(rds, exrds)
def testNodeGetRdataset2(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
z = dns.zone.from_text(example_text, 'example.', relativize=True)
ns = [n for n, r in z.iterate_rdatasets('A')]
ns.sort()
- self.assertTrue(ns == [dns.name.from_text('ns1', None),
- dns.name.from_text('ns2', None)])
+ self.assertEqual(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.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),
- dns.name.from_text('ns2', None)])
+ self.assertEqual(ns, [dns.name.from_text('@', None),
+ dns.name.from_text('@', None),
+ dns.name.from_text('bar.foo', None),
+ dns.name.from_text('ns1', None),
+ dns.name.from_text('ns2', None)])
def testIterateRdatas(self): # type: () -> None
z = dns.zone.from_text(example_text, 'example.', relativize=True)
3600,
dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
'10.0.0.2'))]
- self.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(l == exl)
+ self.assertEqual(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.assertTrue(rds.ttl == 3600)
+ self.assertEqual(rds.ttl, 3600)
n = z['ns1']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.assertTrue(rds.ttl == 86401)
+ self.assertEqual(rds.ttl, 86401)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.assertTrue(rds.ttl == 694861)
+ self.assertEqual(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.assertTrue(rds.ttl == 3600)
+ self.assertEqual(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.assertTrue(rds.ttl == 694861)
+ self.assertEqual(rds.ttl, 694861)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.assertTrue(rds.ttl == soa_rd.minimum)
+ self.assertEqual(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.assertTrue(rds.ttl == 3600)
+ self.assertEqual(rds.ttl, 3600)
n = z['ns1']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.assertTrue(rds.ttl == 3600)
+ self.assertEqual(rds.ttl, 3600)
n = z['ns2']
rds = cast(dns.rdataset.Rdataset, n.get_rdataset(dns.rdataclass.IN, dns.rdatatype.A))
- self.assertTrue(rds.ttl == 694861)
+ self.assertEqual(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.assertTrue(z1 == z2)
+ self.assertEqual(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.assertTrue(rds.ttl == 300)
+ self.assertEqual(rds.ttl, 300)
def testZoneOrigin(self): # type: () -> None
z = dns.zone.Zone('example.')
- self.assertTrue(z.origin == dns.name.from_text('example.'))
+ self.assertEqual(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
