Ticket #223: py30.patch

File py30.patch, 82.4 KB (added by thijs, 9 months ago)

Result of running py2to3's refactor.py against pyamf

  • ez_setup.py

     
    5454        from md5 import md5 
    5555        digest = md5(data).hexdigest() 
    5656        if digest != md5_data[egg_name]: 
    57             print >>sys.stderr, ( 
     57            print(( 
    5858                "md5 validation of %s failed!  (Possible download problem?)" 
    5959                % egg_name 
    60             ) 
     60            ), file=sys.stderr) 
    6161            sys.exit(2) 
    6262    return data 
    6363 
    … …  
    8080    try: 
    8181        import setuptools 
    8282        if setuptools.__version__ == '0.0.1': 
    83             print >>sys.stderr, ( 
     83            print(( 
    8484            "You have an obsolete version of setuptools installed.  Please\n" 
    8585            "remove it from your system entirely before rerunning this script." 
    86             ) 
     86            ), file=sys.stderr) 
    8787            sys.exit(2) 
    8888    except ImportError: 
    8989        egg = download_setuptools(version, download_base, to_dir, download_delay) 
    … …  
    9494    try: 
    9595        pkg_resources.require("setuptools>="+version) 
    9696 
    97     except pkg_resources.VersionConflict, e: 
     97    except pkg_resources.VersionConflict as e: 
    9898        # XXX could we install in a subprocess here? 
    99         print >>sys.stderr, ( 
     99        print(( 
    100100            "The required version of setuptools (>=%s) is not available, and\n" 
    101101            "can't be installed while this script is running. Please install\n" 
    102102            " a more recent version first.\n\n(Currently using %r)" 
    103         ) % (version, e.args[0]) 
     103        ) % (version, e.args[0]), file=sys.stderr) 
    104104        sys.exit(2) 
    105105 
    106106def download_setuptools( 
    … …  
    186186            from setuptools.command.easy_install import main 
    187187            main(argv) 
    188188        else: 
    189             print "Setuptools version",version,"or greater has been installed." 
    190             print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)' 
     189            print("Setuptools version",version,"or greater has been installed.") 
     190            print('(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)') 
    191191 
    192192 
    193193 
    … …  
    203203        md5_data[base] = md5(f.read()).hexdigest() 
    204204        f.close() 
    205205 
    206     data = ["    %r: %r,\n" % it for it in md5_data.items()] 
     206    data = ["    %r: %r,\n" % it for it in list(md5_data.items())] 
    207207    data.sort() 
    208208    repl = "".join(data) 
    209209 
    … …  
    213213 
    214214    match = re.search("\nmd5_data = {\n([^}]+)}", src) 
    215215    if not match: 
    216         print >>sys.stderr, "Internal error!" 
     216        print("Internal error!", file=sys.stderr) 
    217217        sys.exit(2) 
    218218 
    219219    src = src[:match.start(1)] + repl + src[match.end(1):] 

  • pyamf/tests/test_sol.py

     
    6565            'EchoTest\x00\x00\x00\x03\x0fhttpUri\x06=http://localhost:8000' + \ 
    6666            '/gateway/\x00\x0frtmpUri\x06+rtmp://localhost/echo\x00' 
    6767 
    68         self.assertEquals(sol.decode(bytes), (u'EchoTest', 
    69             {u'httpUri': u'http://localhost:8000/gateway/', u'rtmpUri': u'rtmp://localhost/echo'})) 
     68        self.assertEquals(sol.decode(bytes), ('EchoTest', 
     69            {'httpUri': 'http://localhost:8000/gateway/', 'rtmpUri': 'rtmp://localhost/echo'})) 
    7070 
    7171class EncoderTestCase(unittest.TestCase): 
    7272    def test_encode_header(self): 
    … …  
    8585            'EchoTest\x00\x00\x00\x03\x0fhttpUri\x06=http://localhost:8000' + \ 
    8686            '/gateway/\x00\x0frtmpUri\x06+rtmp://localhost/echo\x00' 
    8787 
    88         stream = sol.encode(u'EchoTest', 
    89             {u'httpUri': u'http://localhost:8000/gateway/', u'rtmpUri': u'rtmp://localhost/echo'}, encoding=pyamf.AMF3) 
     88        stream = sol.encode('EchoTest', 
     89            {'httpUri': 'http://localhost:8000/gateway/', 'rtmpUri': 'rtmp://localhost/echo'}, encoding=pyamf.AMF3) 
    9090 
    9191        self.assertEquals(stream.getvalue(), bytes) 
    9292 

  • pyamf/tests/test_util.py

     
    1414import unittest 
    1515 
    1616from datetime import datetime 
    17 from StringIO import StringIO 
     17from io import StringIO 
    1818 
    1919from pyamf import util 
    2020 
    … …  
    3232    """ 
    3333    """ 
    3434    def setUp(self): 
    35         from StringIO import StringIO 
     35        from io import StringIO 
    3636 
    3737        self.previous = util.StringIOProxy._wrapped_class 
    3838        util.StringIOProxy._wrapped_class = StringIO 
    … …  
    267267 
    268268class cStringIOProxyTestCase(StringIOProxyTestCase): 
    269269    def setUp(self): 
    270         from cStringIO import StringIO 
     270        from io import StringIO 
    271271 
    272272        self.previous = util.StringIOProxy._wrapped_class 
    273273        util.StringIOProxy._wrapped_class = StringIO 
    … …  
    380380        x.write_ulong(ord('a')) 
    381381        self.assertEquals(x.getvalue(), '\x00\x00\x00a') 
    382382 
    383         self.assertRaises(ValueError, x.write_ulong, 4294967296L) 
     383        self.assertRaises(ValueError, x.write_ulong, 4294967296) 
    384384        self.assertRaises(ValueError, x.write_ulong, -1) 
    385385 
    386386    def test_read_ulong(self): 
    387387        x = NetworkStream('\xff\xff\xff\xff') 
    388388 
    389         self.assertEquals(x.read_ulong(), 4294967295L) 
     389        self.assertEquals(x.read_ulong(), 4294967295) 
    390390        self.assertEquals(x.tell(), 4) 
    391391 
    392392        self.assertRaises(EOFError, x.read_ulong) 
    … …  
    452452        self.assertEquals(x.getvalue(), '') 
    453453        self.assertEquals(x.tell(), 0) 
    454454 
    455         x.write_utf8_string(u'ᚠᛇᚻ') 
     455        x.write_utf8_string('ᚠᛇᚻ') 
    456456        self.assertEquals(x.getvalue(), '\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb') 
    457457        self.assertEquals(x.tell(), 9) 
    458458 
    459459    def test_read_utf8_string(self): 
    460460        x = NetworkStream('\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb') 
    461461 
    462         self.assertEquals(x.read_utf8_string(9), u'ᚠᛇᚻ') 
     462        self.assertEquals(x.read_utf8_string(9), 'ᚠᛇᚻ') 
    463463 
    464464    def test_nan(self): 
    465465        import fpconst 

  • pyamf/tests/remoting/test_client.py

     
    340340 
    341341        self.assertEquals(envelope.amfVersion, pyamf.AMF3) 
    342342        self.assertEquals(envelope.clientType, pyamf.ClientTypes.FlashCom) 
    343         self.assertEquals(envelope.keys(), ['/1']) 
     343        self.assertEquals(list(envelope.keys()), ['/1']) 
    344344 
    345345        request = envelope['/1'] 
    346346        self.assertEquals(request.target, 'baz.gak') 
    … …  
    350350 
    351351        self.assertEquals(envelope2.amfVersion, pyamf.AMF3) 
    352352        self.assertEquals(envelope2.clientType, pyamf.ClientTypes.FlashCom) 
    353         self.assertEquals(envelope2.keys(), ['/1']) 
     353        self.assertEquals(list(envelope2.keys()), ['/1']) 
    354354 
    355355        request = envelope2['/1'] 
    356356        self.assertEquals(request.target, 'baz.gak') 
    … …  
    451451        gw.setCredentials('spam', 'eggs') 
    452452        self.assertTrue('Credentials' in gw.headers) 
    453453        self.assertEquals(gw.headers['Credentials'], 
    454             {'userid' : u'spam', 'password': u'eggs'}) 
     454            {'userid' : 'spam', 'password': 'eggs'}) 
    455455 
    456456        envelope = gw.getAMFRequest([]) 
    457457        self.assertTrue('Credentials' in envelope.headers) 

  • pyamf/tests/test_flex.py

     
    6363        x = decoder.readElement() 
    6464 
    6565        self.assertEquals(x.__class__, flex.ArrayCollection) 
    66         self.assertEquals(x.keys(), ['spam']) 
    67         self.assertEquals(x.items(), [('spam', u'eggs')]) 
     66        self.assertEquals(list(x.keys()), ['spam']) 
     67        self.assertEquals(list(x.items()), [('spam', 'eggs')]) 
    6868 
    6969class ObjectProxyTestCase(unittest.TestCase): 
    7070    def test_encode(self): 

  • pyamf/tests/util.py

     
    5656            if self.buf.remaining() != 0: 
    5757                from pyamf.util import hexdump 
    5858 
    59                 print hexdump(self.buf.getvalue()) 
     59                print(hexdump(self.buf.getvalue())) 
    6060 
    6161            # make sure that the entire buffer was consumed 
    6262            testcase.assertEqual(self.buf.remaining(), 0) 

  • pyamf/tests/test_basic.py

     
    7070 
    7171        x = [] 
    7272 
    73         for k, v in bag.iteritems(): 
     73        for k, v in bag.items(): 
    7474            x.append((k, v)) 
    7575 
    7676        self.assertEquals(x, [('spam', 'eggs')]) 
    … …  
    370370 
    371371    def test_encode(self): 
    372372        self.assertEquals('\x02\x00\x07connect\x00?\xf0\x00\x00\x00\x00\x00\x00', 
    373             pyamf.encode(u'connect', 1.0).getvalue()) 
     373            pyamf.encode('connect', 1.0).getvalue()) 
    374374 
    375375    def test_decode(self): 
    376         expected = [u'connect', 1.0] 
     376        expected = ['connect', 1.0] 
    377377        bytes = '\x02\x00\x07connect\x00?\xf0\x00\x00\x00\x00\x00\x00' 
    378378 
    379379        returned = [x for x in pyamf.decode(bytes)] 
    … …  
    392392            pyamf.unregister_class(Spam) 
    393393 
    394394    def test_simple(self): 
    395         self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
     395        self.assertTrue('spam.eggs' not in list(pyamf.CLASS_CACHE.keys())) 
    396396        alias = pyamf.register_class(Spam, 'spam.eggs') 
    397397 
    398         self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys()) 
     398        self.assertTrue('spam.eggs' in list(pyamf.CLASS_CACHE.keys())) 
    399399        self.assertEquals(pyamf.CLASS_CACHE['spam.eggs'], alias) 
    400400 
    401401        self.assertTrue(isinstance(alias, pyamf.ClassAlias)) 
    … …  
    456456        alias = pyamf.register_class(Spam, 'spam.eggs') 
    457457 
    458458        pyamf.unregister_class(Spam) 
    459         self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
     459        self.assertTrue('spam.eggs' not in list(pyamf.CLASS_CACHE.keys())) 
    460460        self.assertTrue(alias not in pyamf.CLASS_CACHE) 
    461461 
    462462    def test_alias(self): 
    463463        alias = pyamf.register_class(Spam, 'spam.eggs') 
    464464 
    465465        pyamf.unregister_class('spam.eggs') 
    466         self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
     466        self.assertTrue('spam.eggs' not in list(pyamf.CLASS_CACHE.keys())) 
    467467        self.assertTrue(alias not in pyamf.CLASS_CACHE) 
    468468 
    469469class ClassLoaderTestCase(unittest.TestCase): 
    … …  
    504504 
    505505        pyamf.register_class_loader(class_loader) 
    506506 
    507         self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
     507        self.assertTrue('spam.eggs' not in list(pyamf.CLASS_CACHE.keys())) 
    508508        pyamf.load_class('spam.eggs') 
    509         self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys()) 
     509        self.assertTrue('spam.eggs' in list(pyamf.CLASS_CACHE.keys())) 
    510510 
    511511        pyamf.unregister_class('spam.eggs') 
    512512 
    … …  
    525525 
    526526        pyamf.register_class_loader(class_loader) 
    527527 
    528         self.assertTrue('spam.eggs' not in pyamf.CLASS_CACHE.keys()) 
     528        self.assertTrue('spam.eggs' not in list(pyamf.CLASS_CACHE.keys())) 
    529529        pyamf.load_class('spam.eggs') 
    530         self.assertTrue('spam.eggs' in pyamf.CLASS_CACHE.keys()) 
     530        self.assertTrue('spam.eggs' in list(pyamf.CLASS_CACHE.keys())) 
    531531 
    532532        pyamf.unregister_class('spam.eggs') 
    533533 
    … …  
    562562        self.assertRaises(TypeError, pyamf.add_type, mod) 
    563563        self.assertRaises(TypeError, pyamf.add_type, {}) 
    564564        self.assertRaises(TypeError, pyamf.add_type, 'spam') 
    565         self.assertRaises(TypeError, pyamf.add_type, u'eggs') 
     565        self.assertRaises(TypeError, pyamf.add_type, 'eggs') 
    566566        self.assertRaises(TypeError, pyamf.add_type, 1) 
    567         self.assertRaises(TypeError, pyamf.add_type, 234234L) 
     567        self.assertRaises(TypeError, pyamf.add_type, 234234) 
    568568        self.assertRaises(TypeError, pyamf.add_type, 34.23) 
    569569        self.assertRaises(TypeError, pyamf.add_type, None) 
    570570        self.assertRaises(TypeError, pyamf.add_type, object()) 
    … …  
    595595        td = pyamf.add_type(ord) 
    596596 
    597597        self.assertTrue(ord in pyamf.TYPE_MAP) 
    598         self.assertTrue(td in pyamf.TYPE_MAP.values()) 
     598        self.assertTrue(td in list(pyamf.TYPE_MAP.values())) 
    599599 
    600600    def test_add_multiple(self): 
    601601        td = pyamf.add_type((chr,)) 
    … …  
    674674        self.assertRaises(TypeError, pyamf.remove_error_class, None) 
    675675 
    676676        pyamf.remove_error_class('abc') 
    677         self.assertFalse('abc' in pyamf.ERROR_CLASS_MAP.keys()) 
     677        self.assertFalse('abc' in list(pyamf.ERROR_CLASS_MAP.keys())) 
    678678        self.assertRaises(KeyError, pyamf.ERROR_CLASS_MAP.__getitem__, 'abc') 
    679679 
    680680        pyamf.ERROR_CLASS_MAP['abc'] = B 

  • pyamf/tests/test_gateway.py

     
    4040        fault = None 
    4141 
    4242        try: 
    43             raise TypeError, "unknown type" 
    44         except TypeError, e: 
     43            raise TypeError("unknown type") 
     44        except TypeError as e: 
    4545            fault = amf0.build_fault(*sys.exc_info()) 
    4646 
    4747        self.assertTrue(isinstance(fault, remoting.ErrorFault)) 
    … …  
    5555        decoder.stream = encoder.stream 
    5656 
    5757        try: 
    58             raise TypeError, "unknown type" 
    59         except TypeError, e: 
     58            raise TypeError("unknown type") 
     59        except TypeError as e: 
    6060            encoder.writeElement(amf0.build_fault(*sys.exc_info())) 
    6161 
    6262        buffer = encoder.stream 
    … …  
    7777 
    7878        try: 
    7979            raise X 
    80         except X, e: 
     80        except X as e: 
    8181            fault = amf0.build_fault(*sys.exc_info()) 
    8282 
    8383        self.assertEquals(fault.code, 'Server.UnknownResource') 
    … …  
    110110 
    111111        x = gateway.ServiceWrapper(add) 
    112112 
    113         self.assertTrue(callable(x)) 
     113        self.assertTrue(hasattr(x, '__call__')) 
    114114        self.assertEquals(x(None, [1, 2]), 3) 
    115115 
    116116        x = gateway.ServiceWrapper('blah') 

  • pyamf/tests/test_amf0.py

     
    158158            ('', '\x02\x00\x00'), 
    159159            ('hello', '\x02\x00\x05hello'), 
    160160            # unicode taken from http://www.columbia.edu/kermit/utf8.html 
    161             (u'ᚠᛇᚻ', '\x02\x00\t\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')] 
     161            ('ᚠᛇᚻ', '\x02\x00\t\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')] 
    162162 
    163163        self._run(data) 
    164164 
    165165    def test_bytestring(self): 
    166166        class UnicodeObject: 
    167167            def __unicode__(self): 
    168                 return u'Mötley CrÃŒe' 
     168                return 'Mötley CrÃŒe' 
    169169 
    170170        class StrObject: 
    171171            def __str__(self): 
    172                 return u'Mötley CrÃŒe' 
     172                return 'Mötley CrÃŒe' 
    173173 
    174174        class ReprObject: 
    175175            def __repr__(self): 
    176                 return u'Mötley CrÃŒe' 
     176                return 'Mötley CrÃŒe' 
    177177 
    178178        self.encoder.writeString(UnicodeObject()) 
    179179        self.assertEquals(self.buf.getvalue(), '\x02\x00\x15M\xc3\x83\xc3\x82' 
    … …  
    513513        self._run([ 
    514514            ('', '\x02\x00\x00'), 
    515515            ('hello', '\x02\x00\x05hello'), 
    516             (u'ᚠᛇᚻ', '\x02\x00\t\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')]) 
     516            ('ᚠᛇᚻ', '\x02\x00\t\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')]) 
    517517 
    518518    def test_longstring(self): 
    519519        self._run([('a' * 65537, '\x0c\x00\x01\x00\x01' + 'a' * 65537)]) 
    … …  
    610610            ([x], '\x0a\x00\x00\x00\x01\x0b\x42\x71\x60\x48\xcf\xed\xd0\x00' 
    611611                '\x00\x00')]) 
    612612        self._run([ 
    613             ([[{u'a': u'spam', u'b': u'eggs'}, {u'a': u'spam', u'b': u'eggs'}]], 
     613            ([[{'a': 'spam', 'b': 'eggs'}, {'a': 'spam', 'b': 'eggs'}]], 
    614614                '\n\x00\x00\x00\x01\n\x00\x00\x00\x02\x08\x00\x00\x00\x00\x00' 
    615615                '\x01a\x02\x00\x04spam\x00\x01b\x02\x00\x04eggs\x00\x00\t\x07' 
    616616                '\x00\x02')]) 

  • pyamf/tests/test_remoting.py

     
    154154        self.assertEquals(it.next()[0], '/1') 
    155155        self.assertEquals(it.next()[0], '/2') 
    156156 
    157         self.assertRaises(StopIteration, it.next) 
     157        self.assertRaises(StopIteration, it.__next__) 
    158158 
    159159    def test_string_reference_with_string_headers(self): 
    160160        msg = remoting.decode('\x00\x03\x00\x01\x00\x0b\x43\x72\x65\x64\x65\x6e\x74\x69\x61\x6c' 
    … …  
    269269        self.assertEquals(it.next()[0], '/2') 
    270270        self.assertEquals(it.next()[0], '/3') 
    271271 
    272         self.assertRaises(StopIteration, it.next) 
     272        self.assertRaises(StopIteration, it.__next__) 
    273273 
    274274class StrictEncodingTestCase(unittest.TestCase): 
    275275    def test_request(self): 

  • pyamf/tests/test_amf3.py

     
    314314    def test_string(self): 
    315315        self._run([ 
    316316            ('hello', '\x06\x0bhello'), 
    317             (u'ᚠᛇᚻ', '\x06\x13\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')]) 
     317            ('ᚠᛇᚻ', '\x06\x13\xe1\x9a\xa0\xe1\x9b\x87\xe1\x9a\xbb')]) 
    318318 
    319319    def test_bytestring(self): 
    320320        class UnicodeObject: 
    321321            def __unicode__(self): 
    322                 return u'Mötley CrÃŒe' 
     322                return 'Mötley CrÃŒe' 
    323323 
    324324        class StrObject: 
    325325            def __str__(self): 
    326                 return u'Mötley CrÃŒe' 
     326                return 'Mötley CrÃŒe' 
    327327 
    328328        class ReprObject: 
    329329            def __repr__(self): 
    330                 return u'Mötley CrÃŒe' 
     330                return 'Mötley CrÃŒe' 
    331331 
    332332        self.encoder.writeString(UnicodeObject()) 
    333333        self.assertEquals(self.buf.getvalue(), '\x06+M\xc3\x83\xc3\x82\xc2\xb6tley Cr\xc3\x83\xc3\x82\xc2\xbce') 
    … …  
    390390            ({'spam': 'eggs'}, '\n\x0b\x01\tspam\x06\teggs\x01')]) 
    391391 
    392392        self._run([ 
    393             ({'a': u'a', 'b': u'b', 'c': u'c', 'd': u'd'}, 
     393            ({'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}, 
    394394                '\n\x0b\x01\x03a\x06\x00\x03c\x06\x02\x03b\x06\x04\x03d\x06\x06\x01')]) 
    395395 
    396396        x = amf3.Decoder('\n\x0b\x01\x03a\x06\x00\x03c\x06\x02\x03b\x06\x04\x03d\x06\x06\x01') 
    397         self.assertEqual(x.readElement(), {'a': u'a', 'b': u'b', 'c': u'c', 'd': u'd'}) 
     397        self.assertEqual(x.readElement(), {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}) 
    398398 
    399399    def test_mixed_array(self): 
    400400        x = pyamf.MixedArray() 
    401         x.update({0:u'hello', 'spam': u'eggs'}) 
     401        x.update({0:'hello', 'spam': 'eggs'}) 
    402402 
    403403        self._run([ 
    404404            (x, '\t\x03\tspam\x06\teggs\x01\x06\x0bhello')]) 
    … …  
    413413 
    414414        y = x.readElement() 
    415415        self.assertTrue(isinstance(y,pyamf.MixedArray)) 
    416         self.assertEqual(y, {'a': u'a', 'b': u'b', 'c': u'c', 'd': u'd', 
     416        self.assertEqual(y, {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd', 
    417417                0: 0, 1: 1, 2: 2, 3: 3}) 
    418418 
    419419    def test_empty_key_string(self): 
    … …  
    433433 
    434434    def test_object(self): 
    435435        self._run([ 
    436             ({'a': u'spam', 'b': 5}, 
     436            ({'a': 'spam', 'b': 5}, 
    437437                '\n\x0b\x01\x03a\x06\tspam\x03b\x04\x05\x01')]) 
    438438 
    439439        pyamf.register_class(Spam, 'org.pyamf.spam') 
    … …  
    652652        self._run([ 
    653653            ('', '\x06\x01'), 
    654654            ('hello', '\x06\x0bhello'), 
    655             (u'჊მერთსი ჹემვედრე, ნუთუ კვლა დამხსნას სოჀლისა ლრომასა, ცეცხლს', 
     655            ('჊მერთსი ჹემვედრე, ნუთუ კვლა დამხსნას სოჀლისა ლრომასა, ცეცხლს', 
    656656                '\x06\x82\x45\xe1\x83\xa6\xe1\x83\x9b\xe1\x83\x94\xe1\x83\xa0' 
    657657                '\xe1\x83\x97\xe1\x83\xa1\xe1\x83\x98\x20\xe1\x83\xa8\xe1\x83' 
    658658                '\x94\xe1\x83\x9b\xe1\x83\x95\xe1\x83\x94\xe1\x83\x93\xe1\x83' 
    … …  
    724724 
    725725    def test_dict(self): 
    726726        self._run([ 
    727             ({0: u'hello', 'foo': u'bar'}, 
     727            ({0: 'hello', 'foo': 'bar'}, 
    728728            '\x09\x03\x07\x66\x6f\x6f\x06\x07\x62\x61\x72\x01\x06\x0b\x68\x65' 
    729729            '\x6c\x6c\x6f')]) 
    730730        self._run([({0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 'a': 'a'}, 
    731731            '\x09\x0d\x03\x61\x06\x00\x01\x04\x00\x04\x01\x04\x02\x04\x03\x04' 
    732732            '\x04\x04\x05')]) 
    733733        self._run([( 
    734             {'a': u'a', 'b': u'b', 'c': u'c', 'd': u'd', 
     734            {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd', 
    735735                0: 0, 1: 1, 2: 2, 3: 3}, 
    736736            '\x09\x09\x03\x62\x06\x00\x03\x64\x06\x02\x03\x61\x06\x04\x03\x63' 
    737737            '\x06\x06\x01\x04\x00\x04\x01\x04\x02\x04\x03') 
    … …  
    740740            ({'a': 1, 'b': 2}, '\x0a\x0b\x01\x03\x62\x04\x02\x03\x61\x04\x01' 
    741741                '\x01')]) 
    742742        self._run([ 
    743             ({'baz': u'hello'}, '\x0a\x0b\x01\x07\x62\x61\x7a\x06\x0b\x68\x65' 
     743            ({'baz': 'hello'}, '\x0a\x0b\x01\x07\x62\x61\x7a\x06\x0b\x68\x65' 
    744744                '\x6c\x6c\x6f\x01')]) 
    745745        self._run([ 
    746             ({'baz': u'hello'}, '\x0a\x13\x01\x07\x62\x61\x7a\x06\x0b\x68\x65' 
     746            ({'baz': 'hello'}, '\x0a\x13\x01\x07\x62\x61\x7a\x06\x0b\x68\x65' 
    747747                '\x6c\x6c\x6f')]) 
    748748 
    749749    def test_object(self): 
    … …  
    11031103    def test_byte(self): 
    11041104        x = amf3.DataOutput(self.encoder) 
    11051105 
    1106         for y in xrange(10): 
     1106        for y in range(10): 
    11071107            x.writeByte(y) 
    11081108 
    11091109        self.assertEquals(self.stream.getvalue(), 
    … …  
    11481148        x = amf3.DataOutput(self.encoder) 
    11491149 
    11501150        x.writeMultiByte('this is a test', 'utf-8') 
    1151         self.assertEquals(self.stream.getvalue(), u'this is a test') 
     1151        self.assertEquals(self.stream.getvalue(), 'this is a test') 
    11521152        self.stream.truncate() 
    11531153 
    1154         x.writeMultiByte(u'ጔΎωσαΜ', 'utf-8') 
     1154        x.writeMultiByte('ጔΎωσαΜ', 'utf-8') 
    11551155        self.assertEquals(self.stream.getvalue(), '\xe1\xbc\x94\xce\xb4\xcf' 
    11561156            '\x89\xcf\x83\xce\xb1\xce\xbd') 
    11571157 
    … …  
    11961196    def test_utf(self): 
    11971197        x = amf3.DataOutput(self.encoder) 
    11981198 
    1199         x.writeUTF(u'ጔΎωσαΜ') 
     1199        x.writeUTF('ጔΎωσαΜ') 
    12001200 
    12011201        self.assertEquals(self.stream.getvalue(), '\x00\r\xe1\xbc\x94\xce' 
    12021202            '\xb4\xcf\x89\xcf\x83\xce\xb1\xce\xbd') 
    … …  
    12041204    def test_utf_bytes(self): 
    12051205        x = amf3.DataOutput(self.encoder) 
    12061206 
    1207         x.writeUTFBytes(u'ጔΎωσαΜ') 
     1207        x.writeUTFBytes('ጔΎωσαΜ') 
    12081208 
    12091209        self.assertEquals(self.stream.getvalue(), 
    12101210            '\xe1\xbc\x94\xce\xb4\xcf\x89\xcf\x83\xce\xb1\xce\xbd') 
    … …  
    12451245        self.stream.write('\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09') 
    12461246        self.stream.seek(0) 
    12471247 
    1248         for y in xrange(10): 
     1248        for y in range(10): 
    12491249            self.assertEquals(x.readByte(), y) 
    12501250 
    12511251    def test_double(self): 
    … …  
    12711271        # TODO nick: test multiple charsets 
    12721272        x = amf3.DataInput(self.decoder) 
    12731273 
    1274         self._test(u'this is a test', u'this is a test', x.readMultiByte, 
     1274        self._test('this is a test', 'this is a test', x.readMultiByte, 
    12751275            14, 'utf-8') 
    12761276        self._test('\xe1\xbc\x94\xce\xb4\xcf\x89\xcf\x83\xce\xb1\xce\xbd', 
    1277             u'ጔΎωσαΜ', x.readMultiByte, 13, 'utf-8') 
     1277            'ጔΎωσαΜ', x.readMultiByte, 13, 'utf-8') 
    12781278 
    12791279    def test_object(self): 
    12801280        x = amf3.DataInput(self.decoder) 
    … …  
    12971297    def test_utf(self): 
    12981298        x = amf3.DataInput(self.decoder) 
    12991299 
    1300         self._test('\x00\x0bhello world', u'hello world', x.readUTF) 
     1300        self._test('\x00\x0bhello world', 'hello world', x.readUTF) 
    13011301        self._test('\x00\r\xe1\xbc\x94\xce\xb4\xcf\x89\xcf\x83\xce\xb1\xce\xbd', 
    1302             u'ጔΎωσαΜ', x.readUTF) 
     1302            'ጔΎωσαΜ', x.readUTF) 
    1303