Changeset 793 for trunk/tests


Ignore:
Timestamp:
Jan 28, 2016, 3:07:41 PM (4 years ago)
Author:
cito
Message:

Improve quoting and typecasting in the pg module

Larger refactoring of the code for adapting and typecasting in the pg module.
Things are now a lot cleaner and clearer.

The _Adapt class is responsible for all adapting of Python objects to their
PostgreSQL equivalents when sending data to the database. The typecasting
from PostgreSQL on output happens in the C module, except for the typecasting
of records which is new and provided by the _CastRecord class.

The classic module also did not work properly when regular type names were
switched on with use_regtypes(True), since the adapting of types relied on
the PyGreSQL type names. This has been solved by adding a new _PgType class
that is essentially the old type name, but augmented with all the necessary
information necessary to adapt types, particularly record types.

All tests in test_classic_dbwrapper now run twice, using opposite settings
for the various configuration settings like use_bool() or use_regtypes(),
in order to make sure that no internal functions rely on default settings.

Location:
trunk/tests
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/tests/test_classic_dbwrapper.py

    r781 r793  
    380380    cls_set_up = False
    381381
     382    regtypes = None
     383
    382384    @classmethod
    383385    def setUpClass(cls):
     
    402404        self.assertTrue(self.cls_set_up)
    403405        self.db = DB()
     406        if self.regtypes is None:
     407            self.regtypes = self.db.use_regtypes()
     408        else:
     409            self.db.use_regtypes(self.regtypes)
    404410        query = self.db.query
    405411        query('set client_encoding=utf8')
     
    986992        r = get_attnames('test')
    987993        self.assertIsInstance(r, dict)
    988         self.assertEqual(r, dict(
    989             i2='int', i4='int', i8='int', d='num',
    990             f4='float', f8='float', m='money',
    991             v4='text', c4='text', t='text'))
     994        if self.regtypes:
     995            self.assertEqual(r, dict(
     996                i2='smallint', i4='integer', i8='bigint', d='numeric',
     997                f4='real', f8='double precision', m='money',
     998                v4='character varying', c4='character', t='text'))
     999        else:
     1000            self.assertEqual(r, dict(
     1001                i2='int', i4='int', i8='int', d='num',
     1002                f4='float', f8='float', m='money',
     1003                v4='text', c4='text', t='text'))
    9921004        self.createTable('test_table',
    9931005            'n int, alpha smallint, beta bool,'
     
    9951007        r = get_attnames('test_table')
    9961008        self.assertIsInstance(r, dict)
    997         self.assertEqual(r, dict(
    998             n='int', alpha='int', beta='bool',
    999             gamma='text', tau='text', v='text'))
     1009        if self.regtypes:
     1010            self.assertEqual(r, dict(
     1011                n='integer', alpha='smallint', beta='boolean',
     1012                gamma='character', tau='text', v='character varying'))
     1013        else:
     1014            self.assertEqual(r, dict(
     1015                n='int', alpha='int', beta='bool',
     1016                gamma='text', tau='text', v='text'))
    10001017
    10011018    def testGetAttnamesWithQuotes(self):
     
    10061023        r = get_attnames(table)
    10071024        self.assertIsInstance(r, dict)
    1008         self.assertEqual(r, {
    1009             'Prime!': 'int', 'much space': 'int', 'Questions?': 'text'})
     1025        if self.regtypes:
     1026            self.assertEqual(r, {
     1027                'Prime!': 'smallint', 'much space': 'integer',
     1028                'Questions?': 'text'})
     1029        else:
     1030            self.assertEqual(r, {
     1031                'Prime!': 'int', 'much space': 'int', 'Questions?': 'text'})
    10101032        table = 'yet another test table for get_attnames()'
    10111033        self.createTable(table,
    10121034            'a smallint, b integer, c bigint,'
    1013             ' e numeric, f float, f2 double precision, m money,'
     1035            ' e numeric, f real, f2 double precision, m money,'
    10141036            ' x smallint, y smallint, z smallint,'
    10151037            ' Normal_NaMe smallint, "Special Name" smallint,'
     
    10181040        r = get_attnames(table)
    10191041        self.assertIsInstance(r, dict)
    1020         self.assertEqual(r, {'a': 'int', 'c': 'int', 'b': 'int',
    1021             'e': 'num', 'f': 'float', 'f2': 'float', 'm': 'money',
    1022             'normal_name': 'int', 'Special Name': 'int',
    1023             'u': 'text', 't': 'text', 'v': 'text',
    1024             'y': 'int', 'x': 'int', 'z': 'int', 'oid': 'int'})
     1042        if self.regtypes:
     1043            self.assertEqual(r, {
     1044                'a': 'smallint', 'b': 'integer', 'c': 'bigint',
     1045                'e': 'numeric', 'f': 'real', 'f2': 'double precision',
     1046                'm': 'money', 'normal_name': 'smallint',
     1047                'Special Name': 'smallint', 'u': 'character',
     1048                't': 'text', 'v': 'character varying', 'y': 'smallint',
     1049                'x': 'smallint', 'z': 'smallint', 'oid': 'oid'})
     1050        else:
     1051            self.assertEqual(r, {'a': 'int', 'b': 'int', 'c': 'int',
     1052                'e': 'num', 'f': 'float', 'f2': 'float', 'm': 'money',
     1053                'normal_name': 'int', 'Special Name': 'int',
     1054                'u': 'text', 't': 'text', 'v': 'text',
     1055                'y': 'int', 'x': 'int', 'z': 'int', 'oid': 'int'})
    10251056
    10261057    def testGetAttnamesWithRegtypes(self):
     
    10311062        use_regtypes = self.db.use_regtypes
    10321063        regtypes = use_regtypes()
    1033         self.assertFalse(regtypes)
     1064        self.assertEqual(regtypes, self.regtypes)
    10341065        use_regtypes(True)
    10351066        try:
     
    10421073            gamma='character', tau='text', v='character varying'))
    10431074
     1075    def testGetAttnamesWithoutRegtypes(self):
     1076        get_attnames = self.db.get_attnames
     1077        self.createTable('test_table',
     1078            ' n int, alpha smallint, beta bool,'
     1079            ' gamma char(5), tau text, v varchar(3)')
     1080        use_regtypes = self.db.use_regtypes
     1081        regtypes = use_regtypes()
     1082        self.assertEqual(regtypes, self.regtypes)
     1083        use_regtypes(False)
     1084        try:
     1085            r = get_attnames("test_table")
     1086            self.assertIsInstance(r, dict)
     1087        finally:
     1088            use_regtypes(regtypes)
     1089        self.assertEqual(r, dict(
     1090            n='int', alpha='int', beta='bool',
     1091            gamma='text', tau='text', v='text'))
     1092
    10441093    def testGetAttnamesIsCached(self):
    10451094        get_attnames = self.db.get_attnames
     1095        int_type = 'integer' if self.regtypes else 'int'
     1096        text_type = 'text'
    10461097        query = self.db.query
    10471098        self.createTable('test_table', 'col int')
    10481099        r = get_attnames("test_table")
    10491100        self.assertIsInstance(r, dict)
    1050         self.assertEqual(r, dict(col='int'))
     1101        self.assertEqual(r, dict(col=int_type))
    10511102        query("alter table test_table alter column col type text")
    10521103        query("alter table test_table add column col2 int")
    10531104        r = get_attnames("test_table")
    1054         self.assertEqual(r, dict(col='int'))
     1105        self.assertEqual(r, dict(col=int_type))
    10551106        r = get_attnames("test_table", flush=True)
    1056         self.assertEqual(r, dict(col='text', col2='int'))
     1107        self.assertEqual(r, dict(col=text_type, col2=int_type))
    10571108        query("alter table test_table drop column col2")
    10581109        r = get_attnames("test_table")
    1059         self.assertEqual(r, dict(col='text', col2='int'))
     1110        self.assertEqual(r, dict(col=text_type, col2=int_type))
    10601111        r = get_attnames("test_table", flush=True)
    1061         self.assertEqual(r, dict(col='text'))
     1112        self.assertEqual(r, dict(col=text_type))
    10621113        query("alter table test_table drop column col")
    10631114        r = get_attnames("test_table")
    1064         self.assertEqual(r, dict(col='text'))
     1115        self.assertEqual(r, dict(col=text_type))
    10651116        r = get_attnames("test_table", flush=True)
    10661117        self.assertEqual(r, dict())
     
    10701121        r = get_attnames('test', flush=True)
    10711122        self.assertIsInstance(r, OrderedDict)
    1072         self.assertEqual(r, OrderedDict([
    1073             ('i2', 'int'), ('i4', 'int'), ('i8', 'int'),
    1074             ('d', 'num'), ('f4', 'float'), ('f8', 'float'), ('m', 'money'),
    1075             ('v4', 'text'), ('c4', 'text'), ('t', 'text')]))
     1123        if self.regtypes:
     1124            self.assertEqual(r, OrderedDict([
     1125                ('i2', 'smallint'), ('i4', 'integer'), ('i8', 'bigint'),
     1126                ('d', 'numeric'), ('f4', 'real'), ('f8', 'double precision'),
     1127                ('m', 'money'), ('v4', 'character varying'),
     1128                ('c4', 'character'), ('t', 'text')]))
     1129        else:
     1130            self.assertEqual(r, OrderedDict([
     1131                ('i2', 'int'), ('i4', 'int'), ('i8', 'int'),
     1132                ('d', 'num'), ('f4', 'float'), ('f8', 'float'), ('m', 'money'),
     1133                ('v4', 'text'), ('c4', 'text'), ('t', 'text')]))
    10761134        if OrderedDict is not dict:
    10771135            r = ' '.join(list(r.keys()))
     
    10831141        r = get_attnames(table)
    10841142        self.assertIsInstance(r, OrderedDict)
    1085         self.assertEqual(r, OrderedDict([
    1086             ('n', 'int'), ('alpha', 'int'), ('v', 'text'),
    1087             ('gamma', 'text'), ('tau', 'text'), ('beta', 'bool')]))
     1143        if self.regtypes:
     1144            self.assertEqual(r, OrderedDict([
     1145                ('n', 'integer'), ('alpha', 'smallint'),
     1146                ('v', 'character varying'), ('gamma', 'character'),
     1147                ('tau', 'text'), ('beta', 'boolean')]))
     1148        else:
     1149            self.assertEqual(r, OrderedDict([
     1150                ('n', 'int'), ('alpha', 'int'), ('v', 'text'),
     1151                ('gamma', 'text'), ('tau', 'text'), ('beta', 'bool')]))
    10881152        if OrderedDict is not dict:
    10891153            r = ' '.join(list(r.keys()))
     
    10971161        r = get_attnames('test', flush=True)
    10981162        self.assertIsInstance(r, AttrDict)
    1099         self.assertEqual(r, AttrDict([
    1100             ('i2', 'int'), ('i4', 'int'), ('i8', 'int'),
    1101             ('d', 'num'), ('f4', 'float'), ('f8', 'float'), ('m', 'money'),
    1102             ('v4', 'text'), ('c4', 'text'), ('t', 'text')]))
     1163        if self.regtypes:
     1164            self.assertEqual(r, AttrDict([
     1165                ('i2', 'smallint'), ('i4', 'integer'), ('i8', 'bigint'),
     1166                ('d', 'numeric'), ('f4', 'real'), ('f8', 'double precision'),
     1167                ('m', 'money'), ('v4', 'character varying'),
     1168                ('c4', 'character'), ('t', 'text')]))
     1169        else:
     1170            self.assertEqual(r, AttrDict([
     1171                ('i2', 'int'), ('i4', 'int'), ('i8', 'int'),
     1172                ('d', 'num'), ('f4', 'float'), ('f8', 'float'), ('m', 'money'),
     1173                ('v4', 'text'), ('c4', 'text'), ('t', 'text')]))
    11031174        r = ' '.join(list(r.keys()))
    11041175        self.assertEqual(r, 'i2 i4 i8 d f4 f8 m v4 c4 t')
     
    11091180        r = get_attnames(table)
    11101181        self.assertIsInstance(r, AttrDict)
    1111         self.assertEqual(r, AttrDict([
    1112             ('n', 'int'), ('alpha', 'int'), ('v', 'text'),
    1113             ('gamma', 'text'), ('tau', 'text'), ('beta', 'bool')]))
     1182        if self.regtypes:
     1183            self.assertEqual(r, AttrDict([
     1184                ('n', 'integer'), ('alpha', 'smallint'),
     1185                ('v', 'character varying'), ('gamma', 'character'),
     1186                ('tau', 'text'), ('beta', 'boolean')]))
     1187        else:
     1188            self.assertEqual(r, AttrDict([
     1189                ('n', 'int'), ('alpha', 'int'), ('v', 'text'),
     1190                ('gamma', 'text'), ('tau', 'text'), ('beta', 'bool')]))
    11141191        r = ' '.join(list(r.keys()))
    11151192        self.assertEqual(r, 'n alpha v gamma tau beta')
     
    29703047            ' b bool[], v4 varchar(4)[], c4 char(4)[], t text[]')
    29713048        r = self.db.get_attnames('arraytest')
    2972         self.assertEqual(r, dict(id='int', i2='int[]', i4='int[]', i8='int[]',
    2973             d='num[]', f4='float[]', f8='float[]', m='money[]',
    2974             b='bool[]', v4='text[]', c4='text[]', t='text[]'))
     3049        if self.regtypes:
     3050            self.assertEqual(r, dict(
     3051                id='smallint', i2='smallint[]', i4='integer[]', i8='bigint[]',
     3052                d='numeric[]', f4='real[]', f8='double precision[]',
     3053                m='money[]', b='boolean[]',
     3054                v4='character varying[]', c4='character[]', t='text[]'))
     3055        else:
     3056            self.assertEqual(r, dict(
     3057                id='int', i2='int[]', i4='int[]', i8='int[]',
     3058                d='num[]', f4='float[]', f8='float[]', m='money[]',
     3059                b='bool[]', v4='text[]', c4='text[]', t='text[]'))
    29753060        decimal = pg.get_decimal()
    29763061        if decimal is Decimal:
     
    30053090        self.assertEqual(r, data)
    30063091
    3007     def testArrayInput(self):
     3092    def testArrayLiteral(self):
    30083093        insert = self.db.insert
    30093094        self.createTable('arraytest', 'i int[], t text[]', oids=True)
     
    30163101        self.assertEqual(r['i'], [1, 2, 3])
    30173102        self.assertEqual(r['t'], ['a', 'b', 'c'])
    3018         r = dict(i="[1, 2, 3]", t="['a', 'b', 'c']")
    3019         self.db.insert('arraytest', r)
    3020         self.assertEqual(r['i'], [1, 2, 3])
    3021         self.assertEqual(r['t'], ['a', 'b', 'c'])
    3022         r = dict(i="array[1, 2, 3]", t="array['a', 'b', 'c']")
    3023         self.db.insert('arraytest', r)
    3024         self.assertEqual(r['i'], [1, 2, 3])
    3025         self.assertEqual(r['t'], ['a', 'b', 'c'])
    3026         r = dict(i="ARRAY[1, 2, 3]", t="ARRAY['a', 'b', 'c']")
     3103        L = pg._Literal
     3104        r = dict(i=L("ARRAY[1, 2, 3]"), t=L("ARRAY['a', 'b', 'c']"))
    30273105        self.db.insert('arraytest', r)
    30283106        self.assertEqual(r['i'], [1, 2, 3])
    30293107        self.assertEqual(r['t'], ['a', 'b', 'c'])
    30303108        r = dict(i="1, 2, 3", t="'a', 'b', 'c'")
    3031         self.assertRaises(ValueError, self.db.insert, 'arraytest', r)
     3109        self.assertRaises(pg.ProgrammingError, self.db.insert, 'arraytest', r)
    30323110
    30333111    def testArrayOfIds(self):
    30343112        self.createTable('arraytest', 'c cid[], o oid[], x xid[]', oids=True)
    30353113        r = self.db.get_attnames('arraytest')
    3036         self.assertEqual(r, dict(oid='int', c='int[]', o='int[]', x='int[]'))
     3114        if self.regtypes:
     3115            self.assertEqual(r, dict(
     3116                oid='oid', c='cid[]', o='oid[]', x='xid[]'))
     3117        else:
     3118            self.assertEqual(r, dict(
     3119                oid='int', c='int[]', o='int[]', x='int[]'))
    30373120        data = dict(c=[11, 12, 13], o=[21, 22, 23], x=[31, 32, 33])
    30383121        r = data.copy()
     
    31263209            self.fail(str(error))
    31273210        r = self.db.get_attnames('arraytest')
    3128         self.assertEqual(r['data'], 'json[]')
     3211        self.assertEqual(r['data'], 'jsonb[]' if self.regtypes else 'json[]')
    31293212        data = [dict(id=815, name='John Doe'), dict(id=816, name='Jane Roe')]
    31303213        jsondecode = pg.get_jsondecode()
     
    31663249        self.db.get('arraytest', r)
    31673250        self.assertEqual(r['data'], data)
     3251
     3252    def testInsertUpdateGetRecord(self):
     3253        query = self.db.query
     3254        query('create type test_person_type as'
     3255            ' (name varchar, age smallint, married bool,'
     3256              ' weight real, salary money)')
     3257        self.addCleanup(query, 'drop type test_person_type')
     3258        self.createTable('test_person', 'person test_person_type',
     3259            temporary=False, oids=True)
     3260        attnames = self.db.get_attnames('test_person')
     3261        self.assertEqual(len(attnames), 2)
     3262        self.assertIn('oid', attnames)
     3263        self.assertIn('person', attnames)
     3264        person_typ = attnames['person']
     3265        if self.regtypes:
     3266            self.assertEqual(person_typ, 'test_person_type')
     3267        else:
     3268            self.assertEqual(person_typ, 'record')
     3269        if self.regtypes:
     3270            self.assertEqual(person_typ.attnames,
     3271                dict(name='character varying', age='smallint',
     3272                    married='boolean', weight='real', salary='money'))
     3273        else:
     3274            self.assertEqual(person_typ.attnames,
     3275                dict(name='text', age='int', married='bool',
     3276                    weight='float', salary='money'))
     3277        decimal = pg.get_decimal()
     3278        if pg.get_bool():
     3279            bool_class = bool
     3280            t, f = True, False
     3281        else:
     3282            bool_class = str
     3283            t, f = 't', 'f'
     3284        person = ('John Doe', 61, t, 99.5, decimal('93456.75'))
     3285        r = self.db.insert('test_person', None, person=person)
     3286        p = r['person']
     3287        self.assertIsInstance(p, tuple)
     3288        self.assertEqual(p, person)
     3289        self.assertEqual(p.name, 'John Doe')
     3290        self.assertIsInstance(p.name, str)
     3291        self.assertIsInstance(p.age, int)
     3292        self.assertIsInstance(p.married, bool_class)
     3293        self.assertIsInstance(p.weight, float)
     3294        self.assertIsInstance(p.salary, decimal)
     3295        person = ('Jane Roe', 59, f, 64.5, decimal('96543.25'))
     3296        r['person'] = person
     3297        self.db.update('test_person', r)
     3298        p = r['person']
     3299        self.assertIsInstance(p, tuple)
     3300        self.assertEqual(p, person)
     3301        self.assertEqual(p.name, 'Jane Roe')
     3302        self.assertIsInstance(p.name, str)
     3303        self.assertIsInstance(p.age, int)
     3304        self.assertIsInstance(p.married, bool_class)
     3305        self.assertIsInstance(p.weight, float)
     3306        self.assertIsInstance(p.salary, decimal)
     3307        r['person'] = None
     3308        self.db.get('test_person', r)
     3309        p = r['person']
     3310        self.assertIsInstance(p, tuple)
     3311        self.assertEqual(p, person)
     3312        self.assertEqual(p.name, 'Jane Roe')
     3313        self.assertIsInstance(p.name, str)
     3314        self.assertIsInstance(p.age, int)
     3315        self.assertIsInstance(p.married, bool_class)
     3316        self.assertIsInstance(p.weight, float)
     3317        self.assertIsInstance(p.salary, decimal)
     3318        person = (None,) * 5
     3319        r = self.db.insert('test_person', None, person=person)
     3320        p = r['person']
     3321        self.assertIsInstance(p, tuple)
     3322        self.assertIsNone(p.name)
     3323        self.assertIsNone(p.age)
     3324        self.assertIsNone(p.married)
     3325        self.assertIsNone(p.weight)
     3326        self.assertIsNone(p.salary)
     3327        r['person'] = None
     3328        self.db.get('test_person', r)
     3329        p = r['person']
     3330        self.assertIsInstance(p, tuple)
     3331        self.assertIsNone(p.name)
     3332        self.assertIsNone(p.age)
     3333        self.assertIsNone(p.married)
     3334        self.assertIsNone(p.weight)
     3335        self.assertIsNone(p.salary)
     3336        r = self.db.insert('test_person', None, person=None)
     3337        self.assertIsNone(r['person'])
     3338        r['person'] = None
     3339        self.db.get('test_person', r)
     3340        self.assertIsNone(r['person'])
     3341
     3342    def testRecordInsertBytea(self):
     3343        query = self.db.query
     3344        query('create type test_person_type as'
     3345            ' (name text, picture bytea)')
     3346        self.addCleanup(query, 'drop type test_person_type')
     3347        self.createTable('test_person', 'person test_person_type',
     3348            temporary=False, oids=True)
     3349        person_typ = self.db.get_attnames('test_person')['person']
     3350        self.assertEqual(person_typ.attnames,
     3351            dict(name='text', picture='bytea'))
     3352        person = ('John Doe', b'O\x00ps\xff!')
     3353        r = self.db.insert('test_person', None, person=person)
     3354        p = r['person']
     3355        self.assertIsInstance(p, tuple)
     3356        self.assertEqual(p, person)
     3357        self.assertEqual(p.name, 'John Doe')
     3358        self.assertIsInstance(p.name, str)
     3359        self.assertEqual(p.picture, person[1])
     3360        self.assertIsInstance(p.picture, bytes)
     3361
     3362    def testRecordInsertJson(self):
     3363        query = self.db.query
     3364        try:
     3365            query('create type test_person_type as'
     3366                ' (name text, data json)')
     3367        except pg.ProgrammingError as error:
     3368            if self.db.server_version < 90200:
     3369                self.skipTest('database does not support json')
     3370            self.fail(str(error))
     3371        self.addCleanup(query, 'drop type test_person_type')
     3372        self.createTable('test_person', 'person test_person_type',
     3373            temporary=False, oids=True)
     3374        person_typ = self.db.get_attnames('test_person')['person']
     3375        self.assertEqual(person_typ.attnames,
     3376            dict(name='text', data='json'))
     3377        person = ('John Doe', dict(age=61, married=True, weight=99.5))
     3378        r = self.db.insert('test_person', None, person=person)
     3379        p = r['person']
     3380        self.assertIsInstance(p, tuple)
     3381        if pg.get_jsondecode() is None:
     3382            p = p._replace(data=json.loads(p.data))
     3383        self.assertEqual(p, person)
     3384        self.assertEqual(p.name, 'John Doe')
     3385        self.assertIsInstance(p.name, str)
     3386        self.assertEqual(p.data, person[1])
     3387        self.assertIsInstance(p.data, dict)
     3388
     3389    def testRecordLiteral(self):
     3390        query = self.db.query
     3391        query('create type test_person_type as'
     3392            ' (name varchar, age smallint)')
     3393        self.addCleanup(query, 'drop type test_person_type')
     3394        self.createTable('test_person', 'person test_person_type',
     3395            temporary=False, oids=True)
     3396        person_typ = self.db.get_attnames('test_person')['person']
     3397        if self.regtypes:
     3398            self.assertEqual(person_typ, 'test_person_type')
     3399        else:
     3400            self.assertEqual(person_typ, 'record')
     3401        if self.regtypes:
     3402            self.assertEqual(person_typ.attnames,
     3403                dict(name='character varying', age='smallint'))
     3404        else:
     3405            self.assertEqual(person_typ.attnames,
     3406                dict(name='text', age='int'))
     3407        person = pg._Literal("('John Doe', 61)")
     3408        r = self.db.insert('test_person', None, person=person)
     3409        p = r['person']
     3410        self.assertIsInstance(p, tuple)
     3411        self.assertEqual(p.name, 'John Doe')
     3412        self.assertIsInstance(p.name, str)
     3413        self.assertEqual(p.age, 61)
     3414        self.assertIsInstance(p.age, int)
    31683415
    31693416    def testNotificationHandler(self):
     
    32563503        cls.set_option('namedresult', None)
    32573504        cls.set_option('jsondecode', None)
     3505        cls.regtypes = not DB().use_regtypes()
    32583506        super(TestDBClassNonStdOpts, cls).setUpClass()
    32593507
  • trunk/tests/test_classic_functions.py

    r791 r793  
    217217        self.assertRaises(TypeError, f, None)
    218218        self.assertRaises(TypeError, f, '{}', 1)
    219         self.assertRaises(TypeError, f, '{}', ',',)
     219        self.assertRaises(TypeError, f, '{}', b',',)
    220220        self.assertRaises(TypeError, f, '{}', None, None)
    221221        self.assertRaises(TypeError, f, '{}', None, 1)
    222         self.assertRaises(TypeError, f, '{}', None, '')
    223         self.assertRaises(ValueError, f, '{}', None, '\\')
    224         self.assertRaises(ValueError, f, '{}', None, '{')
    225         self.assertRaises(ValueError, f, '{}', None, '}')
    226         self.assertRaises(TypeError, f, '{}', None, ',;')
     222        self.assertRaises(TypeError, f, '{}', None, b'')
     223        self.assertRaises(ValueError, f, '{}', None, b'\\')
     224        self.assertRaises(ValueError, f, '{}', None, b'{')
     225        self.assertRaises(ValueError, f, '{}', None, b'}')
     226        self.assertRaises(TypeError, f, '{}', None, b',;')
    227227        self.assertEqual(f('{}'), [])
    228228        self.assertEqual(f('{}', None), [])
     
    489489        self.assertRaises(TypeError, f, None)
    490490        self.assertRaises(TypeError, f, '()', 1)
    491         self.assertRaises(TypeError, f, '()', ',',)
     491        self.assertRaises(TypeError, f, '()', b',',)
    492492        self.assertRaises(TypeError, f, '()', None, None)
    493493        self.assertRaises(TypeError, f, '()', None, 1)
    494         self.assertRaises(TypeError, f, '()', None, '')
    495         self.assertRaises(ValueError, f, '()', None, '\\')
    496         self.assertRaises(ValueError, f, '()', None, '(')
    497         self.assertRaises(ValueError, f, '()', None, ')')
    498         self.assertRaises(TypeError, f, '{}', None, ',;')
     494        self.assertRaises(TypeError, f, '()', None, b'')
     495        self.assertRaises(ValueError, f, '()', None, b'\\')
     496        self.assertRaises(ValueError, f, '()', None, b'(')
     497        self.assertRaises(ValueError, f, '()', None, b')')
     498        self.assertRaises(TypeError, f, '{}', None, b',;')
    499499        self.assertEqual(f('()'), (None,))
    500500        self.assertEqual(f('()', None), (None,))
Note: See TracChangeset for help on using the changeset viewer.