Python b示例

示例#1

文件： test_dump.py 项目： 00zl00/AlfredWorkflow.com

 def test_stringify_key(self):
     items = [(b('bytes'), 'bytes'),
              (1.0, '1.0'),
              (10, '10'),
              (True, 'true'),
              (False, 'false'),
              (None, 'null'),
              (long_type(100), '100')]
     for k, expect in items:
         self.assertEqual(
             json.loads(json.dumps({k: expect})),
             {expect: expect})
         self.assertEqual(
             json.loads(json.dumps({k: expect}, sort_keys=True)),
             {expect: expect})
     self.assertRaises(TypeError, json.dumps, {json: 1})
     for v in [{}, {'other': 1}, {b('derp'): 1, 'herp': 2}]:
         for sort_keys in [False, True]:
             v0 = dict(v)
             v0[json] = 1
             v1 = dict((as_text_type(key), val) for (key, val) in v.items())
             self.assertEqual(
                 json.loads(json.dumps(v0, skipkeys=True, sort_keys=sort_keys)),
                 v1)
             self.assertEqual(
                 json.loads(json.dumps({'': v0}, skipkeys=True, sort_keys=sort_keys)),
                 {'': v1})
             self.assertEqual(
                 json.loads(json.dumps([v0], skipkeys=True, sort_keys=sort_keys)),
                 [v1])

示例#2

文件： test_dump.py 项目： 571451370/devstack_mitaka

 def test_stringify_key(self):
     items = [(b('bytes'), 'bytes'), (1.0, '1.0'), (10, '10'),
              (True, 'true'), (False, 'false'), (None, 'null'),
              (long_type(100), '100')]
     for k, expect in items:
         self.assertEqual(json.loads(json.dumps({k: expect})),
                          {expect: expect})
         self.assertEqual(
             json.loads(json.dumps({k: expect}, sort_keys=True)),
             {expect: expect})
     self.assertRaises(TypeError, json.dumps, {json: 1})
     for v in [{}, {'other': 1}, {b('derp'): 1, 'herp': 2}]:
         for sort_keys in [False, True]:
             v0 = dict(v)
             v0[json] = 1
             v1 = dict((as_text_type(key), val) for (key, val) in v.items())
             self.assertEqual(
                 json.loads(
                     json.dumps(v0, skipkeys=True, sort_keys=sort_keys)),
                 v1)
             self.assertEqual(
                 json.loads(
                     json.dumps({'': v0},
                                skipkeys=True,
                                sort_keys=sort_keys)), {'': v1})
             self.assertEqual(
                 json.loads(
                     json.dumps([v0], skipkeys=True, sort_keys=sort_keys)),
                 [v1])

示例#3

文件： test_decode.py 项目： cloudera/hue

    def test_bytes_decode(self):
        cls = json.decoder.JSONDecoder
        data = b('"\xe2\x82\xac"')
        self.assertEqual(cls().decode(data), u'\u20ac')
        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')

        data = MisbehavingBytesSubtype(b('"\xe2\x82\xac"'))
        self.assertEqual(cls().decode(data), u'\u20ac')
        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')

示例#4

文件： test_decode.py 项目： 0benson0/stock-knowledge-graph

    def test_bytes_decode(self):
        cls = json.decoder.JSONDecoder
        data = b('"\xe2\x82\xac"')
        self.assertEqual(cls().decode(data), u'\u20ac')
        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')

        data = MisbehavingBytesSubtype(b('"\xe2\x82\xac"'))
        self.assertEqual(cls().decode(data), u'\u20ac')
        self.assertEqual(cls(encoding='latin1').decode(data), u'\xe2\x82\xac')
        self.assertEqual(cls(encoding=None).decode(data), u'\u20ac')

示例#5

文件： test_scanstring.py 项目： vsajip/simplejson

 def test_issue3623(self):
     self.assertRaises(ValueError, json.decoder.scanstring, "xxx", 1,
                       "xxx")
     if not PY3:
         self.assertRaises(UnicodeDecodeError,
                           json.encoder.encode_basestring_ascii,
                           b("xx\xff"))

示例#6

 def test_ensure_ascii_false_bytestring_encoding(self):
     # http://code.google.com/p/simplejson/issues/detail?id=48
     doc1 = {u'quux': b('Arr\xc3\xaat sur images')}
     doc2 = {u'quux': u('Arr\xeat sur images')}
     doc_ascii = '{"quux": "Arr\\u00eat sur images"}'
     doc_unicode = u'{"quux": "Arr\xeat sur images"}'
     self.assertEqual(json.dumps(doc1), doc_ascii)
     self.assertEqual(json.dumps(doc2), doc_ascii)
     self.assertEqual(json.dumps(doc1, ensure_ascii=False), doc_unicode)
     self.assertEqual(json.dumps(doc2, ensure_ascii=False), doc_unicode)

示例#7

文件： test_unicode.py 项目： 00zl00/AlfredWorkflow.com

 def test_ensure_ascii_false_bytestring_encoding(self):
     # http://code.google.com/p/simplejson/issues/detail?id=48
     doc1 = {u'quux': b('Arr\xc3\xaat sur images')}
     doc2 = {u'quux': u('Arr\xeat sur images')}
     doc_ascii = '{"quux": "Arr\\u00eat sur images"}'
     doc_unicode = u'{"quux": "Arr\xeat sur images"}'
     self.assertEqual(json.dumps(doc1), doc_ascii)
     self.assertEqual(json.dumps(doc2), doc_ascii)
     self.assertEqual(json.dumps(doc1, ensure_ascii=False), doc_unicode)
     self.assertEqual(json.dumps(doc2, ensure_ascii=False), doc_unicode)

示例#8

文件： test_dump.py 项目： git109/simplejson

 def test_stringify_key(self):
     items = [
         (b("bytes"), "bytes"),
         (1.0, "1.0"),
         (10, "10"),
         (True, "true"),
         (False, "false"),
         (None, "null"),
         (long_type(100), "100"),
     ]
     for k, expect in items:
         self.assertEquals(json.loads(json.dumps({k: expect})), {expect: expect})
         self.assertEquals(json.loads(json.dumps({k: expect}, sort_keys=True)), {expect: expect})
     self.assertRaises(TypeError, json.dumps, {json: 1})
     for v in [{}, {"other": 1}, {b("derp"): 1, "herp": 2}]:
         for sort_keys in [False, True]:
             v0 = dict(v)
             v0[json] = 1
             v1 = dict((as_text_type(key), val) for (key, val) in v.items())
             self.assertEquals(json.loads(json.dumps(v0, skipkeys=True, sort_keys=sort_keys)), v1)
             self.assertEquals(json.loads(json.dumps({"": v0}, skipkeys=True, sort_keys=sort_keys)), {"": v1})
             self.assertEquals(json.loads(json.dumps([v0], skipkeys=True, sort_keys=sort_keys)), [v1])

示例#9

 def test_bytes_toplevel(self):
     self.assertEqual(json.dumps(b('\xe2\x82\xac')), r'"\u20ac"')
     self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'))
     self.assertEqual(json.dumps(b('\xa4'), encoding='iso-8859-1'),
                      r'"\u00a4"')
     self.assertEqual(json.dumps(b('\xa4'), encoding='iso-8859-15'),
                      r'"\u20ac"')
     if PY3:
         self.assertRaises(TypeError, json.dumps, b('\xe2\x82\xac'),
                           encoding=None)
         self.assertRaises(TypeError, json.dumps, b('\xa4'),
                           encoding=None)
         self.assertEqual(json.dumps(b('\xa4'), encoding=None,
                                     default=decode_iso_8859_15),
                         r'"\u20ac"')
     else:
         self.assertEqual(json.dumps(b('\xe2\x82\xac'), encoding=None),
                          r'"\u20ac"')
         self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'),
                           encoding=None)
         self.assertRaises(UnicodeDecodeError, json.dumps, b('\xa4'),
                           encoding=None, default=decode_iso_8859_15)

示例#10

 def test_bytes_nested(self):
     self.assertEqual(json.dumps([b('\xe2\x82\xac')]), r'["\u20ac"]')
     self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')])
     self.assertEqual(json.dumps([b('\xa4')], encoding='iso-8859-1'),
                      r'["\u00a4"]')
     self.assertEqual(json.dumps([b('\xa4')], encoding='iso-8859-15'),
                      r'["\u20ac"]')
     if PY3:
         self.assertRaises(TypeError, json.dumps, [b('\xe2\x82\xac')],
                           encoding=None)
         self.assertRaises(TypeError, json.dumps, [b('\xa4')],
                           encoding=None)
         self.assertEqual(json.dumps([b('\xa4')], encoding=None,
                                     default=decode_iso_8859_15),
                          r'["\u20ac"]')
     else:
         self.assertEqual(json.dumps([b('\xe2\x82\xac')], encoding=None),
                          r'["\u20ac"]')
         self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')],
                           encoding=None)
         self.assertRaises(UnicodeDecodeError, json.dumps, [b('\xa4')],
                           encoding=None, default=decode_iso_8859_15)

示例#11

 def test_misbehaving_bytes_subtype(self):
     data = b("this is some data \xe2\x82\xac")
     self.assertEqual(
         json.dumps(MisbehavingBytesSubtype(data)),
         json.dumps(data)
     )
     self.assertEqual(
         json.dumps([MisbehavingBytesSubtype(data)]),
         json.dumps([data])
     )
     self.assertEqual(
         json.dumps({MisbehavingBytesSubtype(data): 42}),
         json.dumps({data: 42})
     )

示例#12

文件： test_encode_basestring_ascii.py 项目： vsajip/simplejson

from unittest import TestCase

from simplejson.compat import u, b, binary_type, PY3
import simplejson.encoder

CASES = [
    (u('/\u005c"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?'), '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'),
    (u('\u0123\u4567\u89ab\ucdef\uabcd\uef4a'), '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
    (u('controls'), '"controls"'),
    (u('\x08\x0c\n\r\t'), '"\\b\\f\\n\\r\\t"'),
    (u('{"object with 1 member":["array with 1 element"]}'), '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
    (u(' s p a c e d '), '" s p a c e d "'),
    (u('\U0001d120'), '"\\ud834\\udd20"'),
    (u('\u03b1\u03a9'), '"\\u03b1\\u03a9"'),
    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
    (u('\u03b1\u03a9'), '"\\u03b1\\u03a9"'),
    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
    (u('\u03b1\u03a9'), '"\\u03b1\\u03a9"'),
    (u('\u03b1\u03a9'), '"\\u03b1\\u03a9"'),
    (u("`1~!@#$%^&*()_+-={':[,]}|;.</>?"), '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
    (u('\x08\x0c\n\r\t'), '"\\b\\f\\n\\r\\t"'),
    (u('\u0123\u4567\u89ab\ucdef\uabcd\uef4a'), '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
]

class TestEncodeBaseStringAscii(TestCase):
    def test_py_encode_basestring_ascii(self):
        self._test_encode_basestring_ascii(simplejson.encoder.py_encode_basestring_ascii)

    def test_c_encode_basestring_ascii(self):
        if not simplejson.encoder.c_encode_basestring_ascii:
            return

示例#13

文件： test_unicode.py 项目： chethankumarka/SuaaS

 def test_strip_bom(self):
     content = u"\u3053\u3093\u306b\u3061\u308f"
     json_doc = codecs.BOM_UTF8 + b(json.dumps(content))
     self.assertEqual(json.load(BytesIO(json_doc)), content)
     for doc in json_doc, json_doc.decode('utf8'):
         self.assertEqual(json.loads(doc), content)

示例#14

文件： test_unicode.py 项目： runt18/simplejson

 def test_strip_bom(self):
     content = u"\u3053\u3093\u306b\u3061\u308f"
     json_doc = codecs.BOM_UTF8 + b(json.dumps(content))
     self.assertEqual(json.load(BytesIO(json_doc)), content)
     for doc in json_doc, json_doc.decode('utf8'):
         self.assertEqual(json.loads(doc), content)

示例#15

 def test_bytes_key(self):
     self.assertEqual(json.dumps({b('\xe2\x82\xac'): 42}), r'{"\u20ac": 42}')
     self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42})
     self.assertEqual(json.dumps({b('\xa4'): 42}, encoding='iso-8859-1'),
                      r'{"\u00a4": 42}')
     self.assertEqual(json.dumps({b('\xa4'): 42}, encoding='iso-8859-15'),
                      r'{"\u20ac": 42}')
     if PY3:
         self.assertRaises(TypeError, json.dumps, {b('\xe2\x82\xac'): 42},
                           encoding=None)
         self.assertRaises(TypeError, json.dumps, {b('\xa4'): 42},
                           encoding=None)
         self.assertRaises(TypeError, json.dumps, {b('\xa4'): 42},
                           encoding=None, default=decode_iso_8859_15)
         self.assertEqual(json.dumps({b('\xa4'): 42}, encoding=None,
                                     skipkeys=True),
                          r'{}')
     else:
         self.assertEqual(json.dumps({b('\xe2\x82\xac'): 42}, encoding=None),
                          r'{"\u20ac": 42}')
         self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
                           encoding=None)
         self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
                           encoding=None, default=decode_iso_8859_15)
         self.assertRaises(UnicodeDecodeError, json.dumps, {b('\xa4'): 42},
                           encoding=None, skipkeys=True)

示例#16

文件： test_speedups.py 项目： cloudera/hue

 def test_bad_encoding(self):
     with self.assertRaises(UnicodeEncodeError):
         encoder.JSONEncoder(encoding='\udcff').encode({b('key'): 123})

示例#17

文件： test_decode.py 项目： cloudera/hue

 def __bytes__(self):
     return b("bad __bytes__")

示例#18

文件： test_encode_basestring_ascii.py 项目： runt18/simplejson

CASES = [
    (
        u"/\\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?",
        '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"',
    ),
    (u"\u0123\u4567\u89ab\ucdef\uabcd\uef4a", '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
    (u"controls", '"controls"'),
    (u"\x08\x0c\n\r\t", '"\\b\\f\\n\\r\\t"'),
    (
        u'{"object with 1 member":["array with 1 element"]}',
        '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"',
    ),
    (u" s p a c e d ", '" s p a c e d "'),
    (u"\U0001d120", '"\\ud834\\udd20"'),
    (u"\u03b1\u03a9", '"\\u03b1\\u03a9"'),
    (b("\xce\xb1\xce\xa9"), '"\\u03b1\\u03a9"'),
    (u"\u03b1\u03a9", '"\\u03b1\\u03a9"'),
    (b("\xce\xb1\xce\xa9"), '"\\u03b1\\u03a9"'),
    (u"\u03b1\u03a9", '"\\u03b1\\u03a9"'),
    (u"\u03b1\u03a9", '"\\u03b1\\u03a9"'),
    (u"`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
    (u"\x08\x0c\n\r\t", '"\\b\\f\\n\\r\\t"'),
    (u"\u0123\u4567\u89ab\ucdef\uabcd\uef4a", '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
]


class TestEncodeBaseStringAscii(TestCase):
    def test_py_encode_basestring_ascii(self):
        self._test_encode_basestring_ascii(simplejson.encoder.py_encode_basestring_ascii)

    def test_c_encode_basestring_ascii(self):

示例#19

文件： test_decode.py 项目： 0benson0/stock-knowledge-graph

 def __bytes__(self):
     return b("bad __bytes__")

示例#20

def _import_speedups():
    try:
        from simplejson import _speedups
        return _speedups.encode_basestring_ascii, _speedups.make_encoder
    except ImportError:
        return None, None
c_encode_basestring_ascii, c_make_encoder = _import_speedups()

from simplejson.compat import (binary_type, text_type,
                               integer_types, string_types, u, b)
from simplejson.decoder import PosInf

ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
HAS_UTF8 = re.compile(b(r'[\x80-\xff]'))
ESCAPE_DCT = {
    '\\': '\\\\',
    '"': '\\"',
    '\b': '\\b',
    '\f': '\\f',
    '\n': '\\n',
    '\r': '\\r',
    '\t': '\\t',
}
for i in range(0x20):
    #ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
    ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))

FLOAT_REPR = repr

示例#21

from simplejson.compat import b

CASES = [
    (u'/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?',
     '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'
     ),
    (u'\u0123\u4567\u89ab\ucdef\uabcd\uef4a',
     '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
    (u'controls', '"controls"'),
    (u'\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
    (u'{"object with 1 member":["array with 1 element"]}',
     '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
    (u' s p a c e d ', '" s p a c e d "'),
    (u'\U0001d120', '"\\ud834\\udd20"'),
    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
    (b('\xce\xb1\xce\xa9'), '"\\u03b1\\u03a9"'),
    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
    (u'\u03b1\u03a9', '"\\u03b1\\u03a9"'),
    (u"`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
    (u'\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
    (u'\u0123\u4567\u89ab\ucdef\uabcd\uef4a',
     '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
]


class TestEncodeBaseStringAscii(TestCase):
    def test_py_encode_basestring_ascii(self):
        self._test_encode_basestring_ascii(
            simplejson.encoder.py_encode_basestring_ascii)

示例#22

 def test_issue3623(self):
     self.assertRaises(ValueError, json.decoder.scanstring, "xxx", 1, "xxx")
     if not PY3:
         self.assertRaises(UnicodeDecodeError,
                           json.encoder.encode_basestring_ascii,
                           b("xx\xff"))

示例#23

文件： test_speedups.py 项目： doorknob88/cmpe273assignment1

 def test_bad_encoding(self):
     with self.assertRaises(UnicodeEncodeError):
         encoder.JSONEncoder(encoding='\udcff').encode({b('key'): 123})