← Back to branch summary

~ubuntu-branches/ubuntu/saucy/simplejson/saucy-proposed

« back to all changes in this revision

Viewing changes to simplejson/tests/test_unicode.py

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2013-06-13 13:50:06 UTC
  • mfrom: (1.1.26)
  • Revision ID: package-import@ubuntu.com-20130613135006-czq95vh3xi2no8ch
Tags: 3.3.0-0ubuntu1
* New upstream release
* debian/rules: Enable tests.
* Separate docs into its own package:
  - debian/python-simplejson-doc.install: Add.
* Add python3 support:
  - debian/control: Add python3-simplejson binary package. Build-Depend
    on python3-all-dev. Add X-Python3-Version: >= 3.3.
  - debian/python3-simplejson.install: Add.
  - debian/rules: Enable Python 3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
simplejson/tests/test_unicode.py
 
1
import sys
1
2
from unittest import TestCase
2
3
 
3
4
import simplejson as json
 
5
from simplejson.compat import unichr, text_type, b, u
4
6
 
5
7
class TestUnicode(TestCase):
6
8
    def test_encoding1(self):
9
11
        s = u.encode('utf-8')
10
12
        ju = encoder.encode(u)
11
13
        js = encoder.encode(s)
12
 
        self.assertEquals(ju, js)
 
14
        self.assertEqual(ju, js)
13
15
 
14
16
    def test_encoding2(self):
15
17
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
16
18
        s = u.encode('utf-8')
17
19
        ju = json.dumps(u, encoding='utf-8')
18
20
        js = json.dumps(s, encoding='utf-8')
19
 
        self.assertEquals(ju, js)
 
21
        self.assertEqual(ju, js)
20
22
 
21
23
    def test_encoding3(self):
22
24
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
23
25
        j = json.dumps(u)
24
 
        self.assertEquals(j, '"\\u03b1\\u03a9"')
 
26
        self.assertEqual(j, '"\\u03b1\\u03a9"')
25
27
 
26
28
    def test_encoding4(self):
27
29
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
28
30
        j = json.dumps([u])
29
 
        self.assertEquals(j, '["\\u03b1\\u03a9"]')
 
31
        self.assertEqual(j, '["\\u03b1\\u03a9"]')
30
32
 
31
33
    def test_encoding5(self):
32
34
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
33
35
        j = json.dumps(u, ensure_ascii=False)
34
 
        self.assertEquals(j, u'"' + u + u'"')
 
36
        self.assertEqual(j, u'"' + u + u'"')
35
37
 
36
38
    def test_encoding6(self):
37
39
        u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
38
40
        j = json.dumps([u], ensure_ascii=False)
39
 
        self.assertEquals(j, u'["' + u + u'"]')
 
41
        self.assertEqual(j, u'["' + u + u'"]')
40
42
 
41
43
    def test_big_unicode_encode(self):
42
44
        u = u'\U0001d120'
43
 
        self.assertEquals(json.dumps(u), '"\\ud834\\udd20"')
44
 
        self.assertEquals(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
 
45
        self.assertEqual(json.dumps(u), '"\\ud834\\udd20"')
 
46
        self.assertEqual(json.dumps(u, ensure_ascii=False), u'"\U0001d120"')
45
47
 
46
48
    def test_big_unicode_decode(self):
47
49
        u = u'z\U0001d120x'
48
 
        self.assertEquals(json.loads('"' + u + '"'), u)
49
 
        self.assertEquals(json.loads('"z\\ud834\\udd20x"'), u)
 
50
        self.assertEqual(json.loads('"' + u + '"'), u)
 
51
        self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u)
50
52
 
51
53
    def test_unicode_decode(self):
52
54
        for i in range(0, 0xd7ff):
53
55
            u = unichr(i)
54
56
            #s = '"\\u{0:04x}"'.format(i)
55
57
            s = '"\\u%04x"' % (i,)
56
 
            self.assertEquals(json.loads(s), u)
 
58
            self.assertEqual(json.loads(s), u)
57
59
 
58
60
    def test_object_pairs_hook_with_unicode(self):
59
61
        s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
72
74
 
73
75
 
74
76
    def test_default_encoding(self):
75
 
        self.assertEquals(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
 
77
        self.assertEqual(json.loads(u'{"a": "\xe9"}'.encode('utf-8')),
76
78
            {'a': u'\xe9'})
77
79
 
78
80
    def test_unicode_preservation(self):
79
 
        self.assertEquals(type(json.loads(u'""')), unicode)
80
 
        self.assertEquals(type(json.loads(u'"a"')), unicode)
81
 
        self.assertEquals(type(json.loads(u'["a"]')[0]), unicode)
 
81
        self.assertEqual(type(json.loads(u'""')), text_type)
 
82
        self.assertEqual(type(json.loads(u'"a"')), text_type)
 
83
        self.assertEqual(type(json.loads(u'["a"]')[0]), text_type)
82
84
 
83
85
    def test_ensure_ascii_false_returns_unicode(self):
84
86
        # http://code.google.com/p/simplejson/issues/detail?id=48
85
 
        self.assertEquals(type(json.dumps([], ensure_ascii=False)), unicode)
86
 
        self.assertEquals(type(json.dumps(0, ensure_ascii=False)), unicode)
87
 
        self.assertEquals(type(json.dumps({}, ensure_ascii=False)), unicode)
88
 
        self.assertEquals(type(json.dumps("", ensure_ascii=False)), unicode)
 
87
        self.assertEqual(type(json.dumps([], ensure_ascii=False)), text_type)
 
88
        self.assertEqual(type(json.dumps(0, ensure_ascii=False)), text_type)
 
89
        self.assertEqual(type(json.dumps({}, ensure_ascii=False)), text_type)
 
90
        self.assertEqual(type(json.dumps("", ensure_ascii=False)), text_type)
89
91
 
90
92
    def test_ensure_ascii_false_bytestring_encoding(self):
91
93
        # http://code.google.com/p/simplejson/issues/detail?id=48
92
 
        doc1 = {u'quux': 'Arr\xc3\xaat sur images'}
93
 
        doc2 = {u'quux': u'Arr\xeat sur images'}
 
94
        doc1 = {u'quux': b('Arr\xc3\xaat sur images')}
 
95
        doc2 = {u'quux': u('Arr\xeat sur images')}
94
96
        doc_ascii = '{"quux": "Arr\\u00eat sur images"}'
95
97
        doc_unicode = u'{"quux": "Arr\xeat sur images"}'
96
 
        self.assertEquals(json.dumps(doc1), doc_ascii)
97
 
        self.assertEquals(json.dumps(doc2), doc_ascii)
98
 
        self.assertEquals(json.dumps(doc1, ensure_ascii=False), doc_unicode)
99
 
        self.assertEquals(json.dumps(doc2, ensure_ascii=False), doc_unicode)
 
98
        self.assertEqual(json.dumps(doc1), doc_ascii)
 
99
        self.assertEqual(json.dumps(doc2), doc_ascii)
 
100
        self.assertEqual(json.dumps(doc1, ensure_ascii=False), doc_unicode)
 
101
        self.assertEqual(json.dumps(doc2, ensure_ascii=False), doc_unicode)
100
102
 
101
103
    def test_ensure_ascii_linebreak_encoding(self):
102
104
        # http://timelessrepo.com/json-isnt-a-javascript-subset
103
105
        s1 = u'\u2029\u2028'
104
106
        s2 = s1.encode('utf8')
105
107
        expect = '"\\u2029\\u2028"'
106
 
        self.assertEquals(json.dumps(s1), expect)
107
 
        self.assertEquals(json.dumps(s2), expect)
108
 
        self.assertEquals(json.dumps(s1, ensure_ascii=False), expect)
109
 
        self.assertEquals(json.dumps(s2, ensure_ascii=False), expect)
 
108
        self.assertEqual(json.dumps(s1), expect)
 
109
        self.assertEqual(json.dumps(s2), expect)
 
110
        self.assertEqual(json.dumps(s1, ensure_ascii=False), expect)
 
111
        self.assertEqual(json.dumps(s2, ensure_ascii=False), expect)
 
112
 
 
113
    def test_invalid_escape_sequences(self):
 
114
        # incomplete escape sequence
 
115
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u')
 
116
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u1')
 
117
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u12')
 
118
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u123')
 
119
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u1234')
 
120
        # invalid escape sequence
 
121
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u123x"')
 
122
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u12x4"')
 
123
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\u1x34"')
 
124
        self.assertRaises(json.JSONDecodeError, json.loads, '"\\ux234"')
 
125
        if sys.maxunicode > 65535:
 
126
            # invalid escape sequence for low surrogate
 
127
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u"')
 
128
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u0"')
 
129
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u00"')
 
130
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u000"')
 
131
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u000x"')
 
132
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u00x0"')
 
133
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\u0x00"')
 
134
            self.assertRaises(json.JSONDecodeError, json.loads, '"\\ud800\\ux000"')
 
135
 
 
136
    def test_ensure_ascii_still_works(self):
 
137
        # in the ascii range, ensure that everything is the same
 
138
        for c in map(unichr, range(0, 127)):
 
139
            self.assertEqual(
 
140
                json.dumps(c, ensure_ascii=False),
 
141
                json.dumps(c))
 
142
        snowman = u'\N{SNOWMAN}'
 
143
        self.assertEqual(
 
144
            json.dumps(c, ensure_ascii=False),
 
145
            '"' + c + '"')