Initial python 3 port (may have sharp edges still!)

7 files changed, 99 insertions, 104 deletions

diff --git a/tests/Makefile b/tests/Makefile
index 584f6a7..e375d91 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -15,7 +15,7 @@
 
 # $Id: Makefile,v 1.5 2004/03/19 00:17:27 halley Exp $
 
-PYTHON=python
+PYTHON=python3.1
 
 check: test
 
diff --git a/tests/message.py b/tests/message.py
index 7134661..e4b0858 100644
--- a/tests/message.py
+++ b/tests/message.py
@@ -13,7 +13,6 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-import cStringIO
 import os
 import unittest
 
@@ -36,7 +35,7 @@ wwww.dnspython.org. IN A
 goodhex = '04d201000001000000000001047777777709646e73707974686f6e' \
           '036f726700000100010000291000000080000000'
 
-goodwire = goodhex.decode('hex_codec')
+goodwire = bytes.fromhex(goodhex)
 
 answer_text = """id 1234
 opcode QUERY
@@ -66,7 +65,7 @@ goodhex2 = '04d2 8500 0001 0001 0003 0001' \
            'c091 0001 0001 00000e10 0004 cc98ba96'
 
 
-goodwire2 = goodhex2.replace(' ', '').decode('hex_codec')
+goodwire2 = bytes.fromhex(goodhex2.replace(' ', ''))
 
 query_text_2 = """id 1234
 opcode QUERY
@@ -84,7 +83,7 @@ wwww.dnspython.org. IN A
 goodhex3 = '04d2010f0001000000000001047777777709646e73707974686f6e' \
           '036f726700000100010000291000ff0080000000'
 
-goodwire3 = goodhex3.decode('hex_codec')
+goodwire3 = bytes.fromhex(goodhex3)
 
 class MessageTestCase(unittest.TestCase):
 
@@ -130,7 +129,7 @@ class MessageTestCase(unittest.TestCase):
     def test_TooBig(self):
         def bad():
             q = dns.message.from_text(query_text)
-            for i in xrange(0, 25):
+            for i in range(0, 25):
                 rrset = dns.rrset.from_text('foo%d.' % i, 3600,
                                             dns.rdataclass.IN,
                                             dns.rdatatype.A,
@@ -146,13 +145,13 @@ class MessageTestCase(unittest.TestCase):
 
     def test_TrailingJunk(self):
         def bad():
-            badwire = goodwire + '\x00'
+            badwire = goodwire + b'\x00'
             m = dns.message.from_wire(badwire)
         self.failUnlessRaises(dns.message.TrailingJunk, bad)
 
     def test_ShortHeader(self):
         def bad():
-            badwire = '\x00' * 11
+            badwire = b'\x00' * 11
             m = dns.message.from_wire(badwire)
         self.failUnlessRaises(dns.message.ShortHeader, bad)
 
diff --git a/tests/name.py b/tests/name.py
index 1ab4f52..bf05a91 100644
--- a/tests/name.py
+++ b/tests/name.py
@@ -15,8 +15,9 @@
 
 import unittest
 
-import cStringIO
+import io
 import socket
+import sys
 
 import dns.name
 import dns.reversename
@@ -25,18 +26,18 @@ import dns.e164
 class NameTestCase(unittest.TestCase):
     def setUp(self):
         self.origin = dns.name.from_text('example.')
-        
+
     def testFromTextRel1(self):
         n = dns.name.from_text('foo.bar')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testFromTextRel2(self):
         n = dns.name.from_text('foo.bar', origin=self.origin)
-        self.failUnless(n.labels == ('foo', 'bar', 'example', ''))
+        self.failUnless(n.labels == (b'foo', b'bar', b'example', b''))
 
     def testFromTextRel3(self):
         n = dns.name.from_text('foo.bar', origin=None)
-        self.failUnless(n.labels == ('foo', 'bar'))
+        self.failUnless(n.labels == (b'foo', b'bar'))
 
     def testFromTextRel4(self):
         n = dns.name.from_text('@', origin=None)
@@ -48,7 +49,7 @@ class NameTestCase(unittest.TestCase):
 
     def testFromTextAbs1(self):
         n = dns.name.from_text('foo.bar.')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testTortureFromText(self):
         good = [
@@ -80,6 +81,9 @@ class NameTestCase(unittest.TestCase):
             try:
                 n = dns.name.from_text(t)
             except:
+                info = sys.exc_info()
+                print(info[0])
+                print(info[2])
                 self.fail("good test '%s' raised an exception" % t)
         for t in bad:
             caught = False
@@ -97,7 +101,7 @@ class NameTestCase(unittest.TestCase):
 
     def testImmutable2(self):
         def bad():
-            self.origin.labels[0] = 'foo'
+            self.origin.labels[0] = b'foo'
         self.failUnlessRaises(TypeError, bad)
 
     def testAbs1(self):
@@ -155,9 +159,6 @@ class NameTestCase(unittest.TestCase):
     def testCompare4(self):
         self.failUnless(dns.name.root != 1)
 
-    def testCompare5(self):
-        self.failUnless(dns.name.root < 1 or dns.name.root > 1)
-
     def testSubdomain1(self):
         self.failUnless(not dns.name.empty.is_subdomain(dns.name.root))
 
@@ -197,7 +198,7 @@ class NameTestCase(unittest.TestCase):
     def testCanonicalize1(self):
         n = dns.name.from_text('FOO.bar', origin=self.origin)
         c = n.canonicalize()
-        self.failUnless(c.labels == ('foo', 'bar', 'example', ''))
+        self.failUnless(c.labels == (b'foo', b'bar', b'example', b''))
 
     def testToText1(self):
         n = dns.name.from_text('FOO.bar', origin=self.origin)
@@ -240,17 +241,17 @@ class NameTestCase(unittest.TestCase):
     def testSlice1(self):
         n = dns.name.from_text(r'a.b.c.', origin=None)
         s = n[:]
-        self.failUnless(s == ('a', 'b', 'c', ''))
+        self.failUnless(s == (b'a', b'b', b'c', b''))
 
     def testSlice2(self):
         n = dns.name.from_text(r'a.b.c.', origin=None)
         s = n[:2]
-        self.failUnless(s == ('a', 'b'))
+        self.failUnless(s == (b'a', b'b'))
 
     def testSlice3(self):
         n = dns.name.from_text(r'a.b.c.', origin=None)
         s = n[2:]
-        self.failUnless(s == ('c', ''))
+        self.failUnless(s == (b'c', b''))
 
     def testEmptyLabel1(self):
         def bad():
@@ -329,13 +330,13 @@ class NameTestCase(unittest.TestCase):
     def testBadEscape(self):
         def bad():
             n = dns.name.from_text(r'a.b\0q1.c.')
-            print n
+            print(n)
         self.failUnlessRaises(dns.name.BadEscape, bad)
 
     def testDigestable1(self):
         n = dns.name.from_text('FOO.bar')
         d = n.to_digestable()
-        self.failUnless(d == '\x03foo\x03bar\x00')
+        self.failUnless(d == b'\x03foo\x03bar\x00')
 
     def testDigestable2(self):
         n1 = dns.name.from_text('FOO.bar')
@@ -346,13 +347,13 @@ class NameTestCase(unittest.TestCase):
 
     def testDigestable3(self):
         d = dns.name.root.to_digestable()
-        self.failUnless(d == '\x00')
+        self.failUnless(d == b'\x00')
 
     def testDigestable4(self):
         n = dns.name.from_text('FOO.bar', None)
         d = n.to_digestable(dns.name.root)
-        self.failUnless(d == '\x03foo\x03bar\x00')
-        
+        self.failUnless(d == b'\x03foo\x03bar\x00')
+
     def testBadDigestable(self):
         def bad():
             n = dns.name.from_text('FOO.bar', None)
@@ -361,56 +362,56 @@ class NameTestCase(unittest.TestCase):
 
     def testToWire1(self):
         n = dns.name.from_text('FOO.bar')
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         compress = {}
         n.to_wire(f, compress)
-        self.failUnless(f.getvalue() == '\x03FOO\x03bar\x00')
+        self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00')
 
     def testToWire2(self):
         n = dns.name.from_text('FOO.bar')
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         compress = {}
         n.to_wire(f, compress)
         n.to_wire(f, compress)
-        self.failUnless(f.getvalue() == '\x03FOO\x03bar\x00\xc0\x00')
+        self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00')
 
     def testToWire3(self):
         n1 = dns.name.from_text('FOO.bar')
         n2 = dns.name.from_text('foo.bar')
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         compress = {}
         n1.to_wire(f, compress)
         n2.to_wire(f, compress)
-        self.failUnless(f.getvalue() == '\x03FOO\x03bar\x00\xc0\x00')
+        self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\xc0\x00')
 
     def testToWire4(self):
         n1 = dns.name.from_text('FOO.bar')
         n2 = dns.name.from_text('a.foo.bar')
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         compress = {}
         n1.to_wire(f, compress)
         n2.to_wire(f, compress)
-        self.failUnless(f.getvalue() == '\x03FOO\x03bar\x00\x01\x61\xc0\x00')
+        self.failUnless(f.getvalue() == b'\x03FOO\x03bar\x00\x01\x61\xc0\x00')
 
     def testToWire5(self):
         n1 = dns.name.from_text('FOO.bar')
         n2 = dns.name.from_text('a.foo.bar')
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         compress = {}
         n1.to_wire(f, compress)
         n2.to_wire(f, None)
         self.failUnless(f.getvalue() == \
-                        '\x03FOO\x03bar\x00\x01\x61\x03foo\x03bar\x00')
+                        b'\x03FOO\x03bar\x00\x01\x61\x03foo\x03bar\x00')
 
     def testToWire6(self):
         n = dns.name.from_text('FOO.bar')
         v = n.to_wire()
-        self.failUnless(v == '\x03FOO\x03bar\x00')
+        self.failUnless(v == b'\x03FOO\x03bar\x00')
 
     def testBadToWire(self):
         def bad():
             n = dns.name.from_text('FOO.bar', None)
-            f = cStringIO.StringIO()
+            f = io.BytesIO()
             compress = {}
             n.to_wire(f, compress)
         self.failUnlessRaises(dns.name.NeedAbsoluteNameOrOrigin, bad)
@@ -540,7 +541,7 @@ class NameTestCase(unittest.TestCase):
         self.failUnless(n.choose_relativity(o, False) == e)
 
     def testFromWire1(self):
-        w = '\x03foo\x00\xc0\x00'
+        w = b'\x03foo\x00\xc0\x00'
         (n1, cused1) = dns.name.from_wire(w, 0)
         (n2, cused2) = dns.name.from_wire(w, cused1)
         en1 = dns.name.from_text('foo.')
@@ -550,8 +551,8 @@ class NameTestCase(unittest.TestCase):
         self.failUnless(n1 == en1 and cused1 == ecused1 and \
                         n2 == en2 and cused2 == ecused2)
 
-    def testFromWire1(self):
-        w = '\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05'
+    def testFromWire2(self):
+        w = b'\x03foo\x00\x01a\xc0\x00\x01b\xc0\x05'
         current = 0
         (n1, cused1) = dns.name.from_wire(w, current)
         current += cused1
@@ -570,25 +571,25 @@ class NameTestCase(unittest.TestCase):
 
     def testBadFromWire1(self):
         def bad():
-            w = '\x03foo\xc0\x04'
+            w = b'\x03foo\xc0\x04'
             (n, cused) = dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire2(self):
         def bad():
-            w = '\x03foo\xc0\x05'
+            w = b'\x03foo\xc0\x05'
             (n, cused) = dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadPointer, bad)
 
     def testBadFromWire3(self):
         def bad():
-            w = '\xbffoo'
+            w = b'\xbffoo'
             (n, cused) = dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadLabelType, bad)
 
     def testBadFromWire4(self):
         def bad():
-            w = '\x41foo'
+            w = b'\x41foo'
             (n, cused) = dns.name.from_wire(w, 0)
         self.failUnlessRaises(dns.name.BadLabelType, bad)
 
@@ -615,39 +616,39 @@ class NameTestCase(unittest.TestCase):
         self.failUnlessRaises(dns.name.NoParent, bad)
 
     def testFromUnicode1(self):
-        n = dns.name.from_text(u'foo.bar')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        n = dns.name.from_text('foo.bar')
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testFromUnicode2(self):
-        n = dns.name.from_text(u'foo\u1234bar.bar')
-        self.failUnless(n.labels == ('xn--foobar-r5z', 'bar', ''))
+        n = dns.name.from_text('foo\u1234bar.bar')
+        self.failUnless(n.labels == (b'xn--foobar-r5z', b'bar', b''))
 
     def testFromUnicodeAlternateDot1(self):
-        n = dns.name.from_text(u'foo\u3002bar')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        n = dns.name.from_text('foo\u3002bar')
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testFromUnicodeAlternateDot2(self):
-        n = dns.name.from_text(u'foo\uff0ebar')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        n = dns.name.from_text('foo\uff0ebar')
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testFromUnicodeAlternateDot3(self):
-        n = dns.name.from_text(u'foo\uff61bar')
-        self.failUnless(n.labels == ('foo', 'bar', ''))
+        n = dns.name.from_text('foo\uff61bar')
+        self.failUnless(n.labels == (b'foo', b'bar', b''))
 
     def testToUnicode1(self):
-        n = dns.name.from_text(u'foo.bar')
+        n = dns.name.from_text('foo.bar')
         s = n.to_unicode()
-        self.failUnless(s == u'foo.bar.')
+        self.failUnless(s == 'foo.bar.')
 
     def testToUnicode2(self):
-        n = dns.name.from_text(u'foo\u1234bar.bar')
+        n = dns.name.from_text('foo\u1234bar.bar')
         s = n.to_unicode()
-        self.failUnless(s == u'foo\u1234bar.bar.')
+        self.failUnless(s == 'foo\u1234bar.bar.')
 
     def testToUnicode3(self):
         n = dns.name.from_text('foo.bar')
         s = n.to_unicode()
-        self.failUnless(s == u'foo.bar.')
+        self.failUnless(s == 'foo.bar.')
 
     def testReverseIPv4(self):
         e = dns.name.from_text('1.0.0.127.in-addr.arpa.')
diff --git a/tests/ntoaaton.py b/tests/ntoaaton.py
index 77befd2..022cac1 100644
--- a/tests/ntoaaton.py
+++ b/tests/ntoaaton.py
@@ -22,24 +22,24 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_aton1(self):
         a = dns.ipv6.inet_aton('::')
-        self.failUnless(a == '\x00' * 16)
+        self.failUnless(a == b'\x00' * 16)
 
     def test_aton2(self):
         a = dns.ipv6.inet_aton('::1')
-        self.failUnless(a == '\x00' * 15 + '\x01')
+        self.failUnless(a == b'\x00' * 15 + b'\x01')
 
     def test_aton3(self):
         a = dns.ipv6.inet_aton('::10.0.0.1')
-        self.failUnless(a == '\x00' * 12 + '\x0a\x00\x00\x01')
+        self.failUnless(a == b'\x00' * 12 + b'\x0a\x00\x00\x01')
 
     def test_aton4(self):
         a = dns.ipv6.inet_aton('abcd::dcba')
-        self.failUnless(a == '\xab\xcd' + '\x00' * 12 + '\xdc\xba')
+        self.failUnless(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
 
     def test_aton5(self):
         a = dns.ipv6.inet_aton('1:2:3:4:5:6:7:8')
         self.failUnless(a == \
-                        '00010002000300040005000600070008'.decode('hex_codec'))
+                        bytes.fromhex('00010002000300040005000600070008'))
 
     def test_bad_aton1(self):
         def bad():
@@ -58,87 +58,87 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_aton1(self):
         a = dns.ipv6.inet_aton('::')
-        self.failUnless(a == '\x00' * 16)
+        self.failUnless(a == b'\x00' * 16)
 
     def test_aton2(self):
         a = dns.ipv6.inet_aton('::1')
-        self.failUnless(a == '\x00' * 15 + '\x01')
+        self.failUnless(a == b'\x00' * 15 + b'\x01')
 
     def test_aton3(self):
         a = dns.ipv6.inet_aton('::10.0.0.1')
-        self.failUnless(a == '\x00' * 12 + '\x0a\x00\x00\x01')
+        self.failUnless(a == b'\x00' * 12 + b'\x0a\x00\x00\x01')
 
     def test_aton4(self):
         a = dns.ipv6.inet_aton('abcd::dcba')
-        self.failUnless(a == '\xab\xcd' + '\x00' * 12 + '\xdc\xba')
+        self.failUnless(a == b'\xab\xcd' + b'\x00' * 12 + b'\xdc\xba')
 
     def test_ntoa1(self):
-        b = '00010002000300040005000600070008'.decode('hex_codec')
+        b = bytes.fromhex('00010002000300040005000600070008')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '1:2:3:4:5:6:7:8')
 
     def test_ntoa2(self):
-        b = '\x00' * 16
+        b = b'\x00' * 16
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::')
 
     def test_ntoa3(self):
-        b = '\x00' * 15 + '\x01'
+        b = b'\x00' * 15 + b'\x01'
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::1')
 
     def test_ntoa4(self):
-        b = '\x80' + '\x00' * 15
+        b = b'\x80' + b'\x00' * 15
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '8000::')
 
     def test_ntoa5(self):
-        b = '\x01\xcd' + '\x00' * 12 + '\x03\xef'
+        b = b'\x01\xcd' + b'\x00' * 12 + b'\x03\xef'
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '1cd::3ef')
 
     def test_ntoa6(self):
-        b = 'ffff00000000ffff000000000000ffff'.decode('hex_codec')
+        b = bytes.fromhex('ffff00000000ffff000000000000ffff')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == 'ffff:0:0:ffff::ffff')
 
     def test_ntoa7(self):
-        b = '00000000ffff000000000000ffffffff'.decode('hex_codec')
+        b = bytes.fromhex('00000000ffff000000000000ffffffff')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '0:0:ffff::ffff:ffff')
 
     def test_ntoa8(self):
-        b = 'ffff0000ffff00000000ffff00000000'.decode('hex_codec')
+        b = bytes.fromhex('ffff0000ffff00000000ffff00000000')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == 'ffff:0:ffff::ffff:0:0')
 
     def test_ntoa9(self):
-        b = '0000000000000000000000000a000001'.decode('hex_codec')
+        b = bytes.fromhex('0000000000000000000000000a000001')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::10.0.0.1')
 
     def test_ntoa10(self):
-        b = '0000000000000000000000010a000001'.decode('hex_codec')
+        b = bytes.fromhex('0000000000000000000000010a000001')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::1:a00:1')
 
     def test_ntoa11(self):
-        b = '00000000000000000000ffff0a000001'.decode('hex_codec')
+        b = bytes.fromhex('00000000000000000000ffff0a000001')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::ffff:10.0.0.1')
 
     def test_ntoa12(self):
-        b = '000000000000000000000000ffffffff'.decode('hex_codec')
+        b = bytes.fromhex('000000000000000000000000ffffffff')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::255.255.255.255')
 
     def test_ntoa13(self):
-        b = '00000000000000000000ffffffffffff'.decode('hex_codec')
+        b = bytes.fromhex('00000000000000000000ffffffffffff')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::ffff:255.255.255.255')
 
     def test_ntoa14(self):
-        b = '0000000000000000000000000001ffff'.decode('hex_codec')
+        b = bytes.fromhex('0000000000000000000000000001ffff')
         t = dns.ipv6.inet_ntoa(b)
         self.failUnless(t == '::0.1.255.255')
 
@@ -149,7 +149,7 @@ class NtoAAtoNTestCase(unittest.TestCase):
 
     def test_bad_ntoa2(self):
         def bad():
-            a = dns.ipv6.inet_ntoa('\x00' * 17)
+            a = dns.ipv6.inet_ntoa(b'\x00' * 17)
         self.failUnlessRaises(ValueError, bad)
 
 if __name__ == '__main__':
diff --git a/tests/resolver.py b/tests/resolver.py
index 4cacbdc..f29fa28 100644
--- a/tests/resolver.py
+++ b/tests/resolver.py
@@ -13,7 +13,7 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-import cStringIO
+import io
 import sys
 import time
 import unittest
@@ -50,7 +50,7 @@ class ResolverTestCase(unittest.TestCase):
 
     if sys.platform != 'win32':
         def testRead(self):
-            f = cStringIO.StringIO(resolv_conf)
+            f = io.StringIO(resolv_conf)
             r = dns.resolver.Resolver(f)
             self.failUnless(r.nameservers == ['10.0.0.1', '10.0.0.2'] and
                             r.domain == dns.name.from_text('foo'))
diff --git a/tests/update.py b/tests/update.py
index 5f7b31f..e725454 100644
--- a/tests/update.py
+++ b/tests/update.py
@@ -34,7 +34,7 @@ goodhex = '0001 2800 0001 0005 0007 0000' \
           '04626c617ac00c 0001 00ff 00000000 0000' \
           'c049 00ff 00ff 00000000 0000'
 
-goodwire = goodhex.replace(' ', '').decode('hex_codec')
+goodwire = bytes.fromhex(goodhex.replace(' ', ''))
 
 update_text="""id 1
 opcode UPDATE
diff --git a/tests/zone.py b/tests/zone.py
index 075be0a..c34164a 100644
--- a/tests/zone.py
+++ b/tests/zone.py
@@ -13,7 +13,7 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-import cStringIO
+import io
 import filecmp
 import os
 import unittest
@@ -123,23 +123,22 @@ class ZoneTestCase(unittest.TestCase):
 
     def testFromText(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
-        f = cStringIO.StringIO()
-        names = z.nodes.keys()
-        names.sort()
+        f = io.StringIO()
+        names = sorted(z.nodes.keys())
         for n in names:
-            print >> f, z[n].to_text(n)
+            print(z[n].to_text(n), file=f)
         self.failUnless(f.getvalue() == example_text_output)
-            
+
     def testTorture1(self):
         #
         # Read a zone containing all our supported RR types, and
         # for each RR in the zone, convert the rdata into wire format
         # and then back out, and see if we get equal rdatas.
         #
-        f = cStringIO.StringIO()
+        f = io.BytesIO()
         o = dns.name.from_text('example.')
         z = dns.zone.from_file('example', o)
-        for (name, node) in z.iteritems():
+        for (name, node) in z.items():
             for rds in node:
                 for rd in rds:
                     f.seek(0)
@@ -290,15 +289,13 @@ class ZoneTestCase(unittest.TestCase):
 
     def testIterateRdatasets(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
-        ns = [n for n, r in z.iterate_rdatasets('A')]
-        ns.sort()
+        ns = sorted([n for n, r in z.iterate_rdatasets('A')])
         self.failUnless(ns == [dns.name.from_text('ns1', None),
                                dns.name.from_text('ns2', None)])
 
     def testIterateAllRdatasets(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
-        ns = [n for n, r in z.iterate_rdatasets()]
-        ns.sort()
+        ns = sorted([n for n, r in z.iterate_rdatasets()])
         self.failUnless(ns == [dns.name.from_text('@', None),
                                dns.name.from_text('@', None),
                                dns.name.from_text('bar.foo', None),
@@ -307,8 +304,7 @@ class ZoneTestCase(unittest.TestCase):
 
     def testIterateRdatas(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
-        l = list(z.iterate_rdatas('A'))
-        l.sort()
+        l = sorted(z.iterate_rdatas('A'))
         exl = [(dns.name.from_text('ns1', None),
                 3600,
                 dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.A,
@@ -321,8 +317,7 @@ class ZoneTestCase(unittest.TestCase):
 
     def testIterateAllRdatas(self):
         z = dns.zone.from_text(example_text, 'example.', relativize=True)
-        l = list(z.iterate_rdatas())
-        l.sort()
+        l = sorted(z.iterate_rdatas())
         exl = [(dns.name.from_text('@', None),
                 3600,
                 dns.rdata.from_text(dns.rdataclass.IN, dns.rdatatype.NS,