com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/test/test_json/__init__.py

@@ -1,56 +0,0 @@
-import os
-import json
-import doctest
-import unittest
-
-from test import support
-
-# import json with and without accelerations
-cjson = support.import_fresh_module('json', fresh=['_json'])
-pyjson = support.import_fresh_module('json', blocked=['_json'])
-# JSONDecodeError is cached inside the _json module
-cjson.JSONDecodeError = cjson.decoder.JSONDecodeError = json.JSONDecodeError
-
-# create two base classes that will be used by the other tests
-class PyTest(unittest.TestCase):
-    json = pyjson
-    loads = staticmethod(pyjson.loads)
-    dumps = staticmethod(pyjson.dumps)
-    JSONDecodeError = staticmethod(pyjson.JSONDecodeError)
-
-@unittest.skipUnless(cjson, 'requires _json')
-class CTest(unittest.TestCase):
-    if cjson is not None:
-        json = cjson
-        loads = staticmethod(cjson.loads)
-        dumps = staticmethod(cjson.dumps)
-        JSONDecodeError = staticmethod(cjson.JSONDecodeError)
-
-# test PyTest and CTest checking if the functions come from the right module
-class TestPyTest(PyTest):
-    def test_pyjson(self):
-        self.assertEqual(self.json.scanner.make_scanner.__module__,
-                         'json.scanner')
-        self.assertEqual(self.json.decoder.scanstring.__module__,
-                         'json.decoder')
-        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
-                         'json.encoder')
-
-class TestCTest(CTest):
-    def test_cjson(self):
-        self.assertEqual(self.json.scanner.make_scanner.__module__, '_json')
-        self.assertEqual(self.json.decoder.scanstring.__module__, '_json')
-        self.assertEqual(self.json.encoder.c_make_encoder.__module__, '_json')
-        self.assertEqual(self.json.encoder.encode_basestring_ascii.__module__,
-                         '_json')
-
-
-def load_tests(loader, _, pattern):
-    suite = unittest.TestSuite()
-    for mod in (json, json.encoder, json.decoder):
-        suite.addTest(doctest.DocTestSuite(mod))
-    suite.addTest(TestPyTest('test_pyjson'))
-    suite.addTest(TestCTest('test_cjson'))
-
-    pkg_dir = os.path.dirname(__file__)
-    return support.load_package_tests(pkg_dir, loader, suite, pattern)

package/python3.6.2/lib/python3.6/test/test_json/__main__.py

@@ -1,4 +0,0 @@
-import unittest
-from test.test_json import load_tests
-
-unittest.main()

package/python3.6.2/lib/python3.6/test/test_json/test_decode.py

@@ -1,97 +0,0 @@
-import decimal
-from io import StringIO, BytesIO
-from collections import OrderedDict
-from test.test_json import PyTest, CTest
-
-
-class TestDecode:
-    def test_decimal(self):
-        rval = self.loads('1.1', parse_float=decimal.Decimal)
-        self.assertTrue(isinstance(rval, decimal.Decimal))
-        self.assertEqual(rval, decimal.Decimal('1.1'))
-
-    def test_float(self):
-        rval = self.loads('1', parse_int=float)
-        self.assertTrue(isinstance(rval, float))
-        self.assertEqual(rval, 1.0)
-
-    def test_empty_objects(self):
-        self.assertEqual(self.loads('{}'), {})
-        self.assertEqual(self.loads('[]'), [])
-        self.assertEqual(self.loads('""'), "")
-
-    def test_object_pairs_hook(self):
-        s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}'
-        p = [("xkd", 1), ("kcw", 2), ("art", 3), ("hxm", 4),
-             ("qrt", 5), ("pad", 6), ("hoy", 7)]
-        self.assertEqual(self.loads(s), eval(s))
-        self.assertEqual(self.loads(s, object_pairs_hook=lambda x: x), p)
-        self.assertEqual(self.json.load(StringIO(s),
-                                        object_pairs_hook=lambda x: x), p)
-        od = self.loads(s, object_pairs_hook=OrderedDict)
-        self.assertEqual(od, OrderedDict(p))
-        self.assertEqual(type(od), OrderedDict)
-        # the object_pairs_hook takes priority over the object_hook
-        self.assertEqual(self.loads(s, object_pairs_hook=OrderedDict,
-                                    object_hook=lambda x: None),
-                         OrderedDict(p))
-        # check that empty object literals work (see #17368)
-        self.assertEqual(self.loads('{}', object_pairs_hook=OrderedDict),
-                         OrderedDict())
-        self.assertEqual(self.loads('{"empty": {}}',
-                                    object_pairs_hook=OrderedDict),
-                         OrderedDict([('empty', OrderedDict())]))
-
-    def test_decoder_optimizations(self):
-        # Several optimizations were made that skip over calls to
-        # the whitespace regex, so this test is designed to try and
-        # exercise the uncommon cases. The array cases are already covered.
-        rval = self.loads('{   "key"    :    "value"    ,  "k":"v"    }')
-        self.assertEqual(rval, {"key":"value", "k":"v"})
-
-    def check_keys_reuse(self, source, loads):
-        rval = loads(source)
-        (a, b), (c, d) = sorted(rval[0]), sorted(rval[1])
-        self.assertIs(a, c)
-        self.assertIs(b, d)
-
-    def test_keys_reuse(self):
-        s = '[{"a_key": 1, "b_\xe9": 2}, {"a_key": 3, "b_\xe9": 4}]'
-        self.check_keys_reuse(s, self.loads)
-        self.check_keys_reuse(s, self.json.decoder.JSONDecoder().decode)
-
-    def test_extra_data(self):
-        s = '[1, 2, 3]5'
-        msg = 'Extra data'
-        self.assertRaisesRegex(self.JSONDecodeError, msg, self.loads, s)
-
-    def test_invalid_escape(self):
-        s = '["abc\\y"]'
-        msg = 'escape'
-        self.assertRaisesRegex(self.JSONDecodeError, msg, self.loads, s)
-
-    def test_invalid_input_type(self):
-        msg = 'the JSON object must be str'
-        for value in [1, 3.14, [], {}, None]:
-            self.assertRaisesRegex(TypeError, msg, self.loads, value)
-
-    def test_string_with_utf8_bom(self):
-        # see #18958
-        bom_json = "[1,2,3]".encode('utf-8-sig').decode('utf-8')
-        with self.assertRaises(self.JSONDecodeError) as cm:
-            self.loads(bom_json)
-        self.assertIn('BOM', str(cm.exception))
-        with self.assertRaises(self.JSONDecodeError) as cm:
-            self.json.load(StringIO(bom_json))
-        self.assertIn('BOM', str(cm.exception))
-        # make sure that the BOM is not detected in the middle of a string
-        bom_in_str = '"{}"'.format(''.encode('utf-8-sig').decode('utf-8'))
-        self.assertEqual(self.loads(bom_in_str), '\ufeff')
-        self.assertEqual(self.json.load(StringIO(bom_in_str)), '\ufeff')
-
-    def test_negative_index(self):
-        d = self.json.JSONDecoder()
-        self.assertRaises(ValueError, d.raw_decode, 'a'*42, -50000)
-
-class TestPyDecode(TestDecode, PyTest): pass
-class TestCDecode(TestDecode, CTest): pass

package/python3.6.2/lib/python3.6/test/test_json/test_default.py

@@ -1,12 +0,0 @@
-from test.test_json import PyTest, CTest
-
-
-class TestDefault:
-    def test_default(self):
-        self.assertEqual(
-            self.dumps(type, default=repr),
-            self.dumps(repr(type)))
-
-
-class TestPyDefault(TestDefault, PyTest): pass
-class TestCDefault(TestDefault, CTest): pass

package/python3.6.2/lib/python3.6/test/test_json/test_dump.py

@@ -1,68 +0,0 @@
-from io import StringIO
-from test.test_json import PyTest, CTest
-
-from test.support import bigmemtest, _1G
-
-class TestDump:
-    def test_dump(self):
-        sio = StringIO()
-        self.json.dump({}, sio)
-        self.assertEqual(sio.getvalue(), '{}')
-
-    def test_dumps(self):
-        self.assertEqual(self.dumps({}), '{}')
-
-    def test_encode_truefalse(self):
-        self.assertEqual(self.dumps(
-                 {True: False, False: True}, sort_keys=True),
-                 '{"false": true, "true": false}')
-        self.assertEqual(self.dumps(
-                {2: 3.0, 4.0: 5, False: 1, 6: True}, sort_keys=True),
-                '{"false": 1, "2": 3.0, "4.0": 5, "6": true}')
-
-    # Issue 16228: Crash on encoding resized list
-    def test_encode_mutated(self):
-        a = [object()] * 10
-        def crasher(obj):
-            del a[-1]
-        self.assertEqual(self.dumps(a, default=crasher),
-                 '[null, null, null, null, null]')
-
-    # Issue 24094
-    def test_encode_evil_dict(self):
-        class D(dict):
-            def keys(self):
-                return L
-
-        class X:
-            def __hash__(self):
-                del L[0]
-                return 1337
-
-            def __lt__(self, o):
-                return 0
-
-        L = [X() for i in range(1122)]
-        d = D()
-        d[1337] = "true.dat"
-        self.assertEqual(self.dumps(d, sort_keys=True), '{"1337": "true.dat"}')
-
-
-class TestPyDump(TestDump, PyTest): pass
-
-class TestCDump(TestDump, CTest):
-
-    # The size requirement here is hopefully over-estimated (actual
-    # memory consumption depending on implementation details, and also
-    # system memory management, since this may allocate a lot of
-    # small objects).
-
-    @bigmemtest(size=_1G, memuse=1)
-    def test_large_list(self, size):
-        N = int(30 * 1024 * 1024 * (size / _1G))
-        l = [1] * N
-        encoded = self.dumps(l)
-        self.assertEqual(len(encoded), N * 3)
-        self.assertEqual(encoded[:1], "[")
-        self.assertEqual(encoded[-2:], "1]")
-        self.assertEqual(encoded[1:-2], "1, " * (N - 1))

package/python3.6.2/lib/python3.6/test/test_json/test_encode_basestring_ascii.py

@@ -1,48 +0,0 @@
-from collections import OrderedDict
-from test.test_json import PyTest, CTest
-from test.support import bigaddrspacetest
-
-
-CASES = [
-    ('/\\"\ucafe\ubabe\uab98\ufcde\ubcda\uef4a\x08\x0c\n\r\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?', '"/\\\\\\"\\ucafe\\ubabe\\uab98\\ufcde\\ubcda\\uef4a\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:\',./<>?"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
-    ('controls', '"controls"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
-    (' s p a c e d ', '" s p a c e d "'),
-    ('\U0001d120', '"\\ud834\\udd20"'),
-    ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
-    ("`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
-]
-
-class TestEncodeBasestringAscii:
-    def test_encode_basestring_ascii(self):
-        fname = self.json.encoder.encode_basestring_ascii.__name__
-        for input_string, expect in CASES:
-            result = self.json.encoder.encode_basestring_ascii(input_string)
-            self.assertEqual(result, expect,
-                '{0!r} != {1!r} for {2}({3!r})'.format(
-                    result, expect, fname, input_string))
-
-    def test_ordered_dict(self):
-        # See issue 6105
-        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
-        s = self.dumps(OrderedDict(items))
-        self.assertEqual(s, '{"one": 1, "two": 2, "three": 3, "four": 4, "five": 5}')
-
-    def test_sorted_dict(self):
-        items = [('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)]
-        s = self.dumps(dict(items), sort_keys=True)
-        self.assertEqual(s, '{"five": 5, "four": 4, "one": 1, "three": 3, "two": 2}')
-
-
-class TestPyEncodeBasestringAscii(TestEncodeBasestringAscii, PyTest): pass
-class TestCEncodeBasestringAscii(TestEncodeBasestringAscii, CTest):
-    @bigaddrspacetest
-    def test_overflow(self):
-        size = (2**32)//6 + 1
-        s = "\x00"*size
-        with self.assertRaises(OverflowError):
-            self.json.encoder.encode_basestring_ascii(s)

package/python3.6.2/lib/python3.6/test/test_json/test_enum.py

@@ -1,120 +0,0 @@
-from enum import Enum, IntEnum
-from math import isnan
-from test.test_json import PyTest, CTest
-
-SMALL = 1
-BIG = 1<<32
-HUGE = 1<<64
-REALLY_HUGE = 1<<96
-
-class BigNum(IntEnum):
-    small = SMALL
-    big = BIG
-    huge = HUGE
-    really_huge = REALLY_HUGE
-
-E = 2.718281
-PI = 3.141593
-TAU = 2 * PI
-
-class FloatNum(float, Enum):
-    e = E
-    pi = PI
-    tau = TAU
-
-INF = float('inf')
-NEG_INF = float('-inf')
-NAN = float('nan')
-
-class WierdNum(float, Enum):
-    inf = INF
-    neg_inf = NEG_INF
-    nan = NAN
-
-class TestEnum:
-
-    def test_floats(self):
-        for enum in FloatNum:
-            self.assertEqual(self.dumps(enum), repr(enum.value))
-            self.assertEqual(float(self.dumps(enum)), enum)
-            self.assertEqual(self.loads(self.dumps(enum)), enum)
-
-    def test_weird_floats(self):
-        for enum, expected in zip(WierdNum, ('Infinity', '-Infinity', 'NaN')):
-            self.assertEqual(self.dumps(enum), expected)
-            if not isnan(enum):
-                self.assertEqual(float(self.dumps(enum)), enum)
-                self.assertEqual(self.loads(self.dumps(enum)), enum)
-            else:
-                self.assertTrue(isnan(float(self.dumps(enum))))
-                self.assertTrue(isnan(self.loads(self.dumps(enum))))
-
-    def test_ints(self):
-        for enum in BigNum:
-            self.assertEqual(self.dumps(enum), str(enum.value))
-            self.assertEqual(int(self.dumps(enum)), enum)
-            self.assertEqual(self.loads(self.dumps(enum)), enum)
-
-    def test_list(self):
-        self.assertEqual(self.dumps(list(BigNum)),
-                         str([SMALL, BIG, HUGE, REALLY_HUGE]))
-        self.assertEqual(self.loads(self.dumps(list(BigNum))),
-                         list(BigNum))
-        self.assertEqual(self.dumps(list(FloatNum)),
-                         str([E, PI, TAU]))
-        self.assertEqual(self.loads(self.dumps(list(FloatNum))),
-                         list(FloatNum))
-        self.assertEqual(self.dumps(list(WierdNum)),
-                        '[Infinity, -Infinity, NaN]')
-        self.assertEqual(self.loads(self.dumps(list(WierdNum)))[:2],
-                         list(WierdNum)[:2])
-        self.assertTrue(isnan(self.loads(self.dumps(list(WierdNum)))[2]))
-
-    def test_dict_keys(self):
-        s, b, h, r = BigNum
-        e, p, t = FloatNum
-        i, j, n = WierdNum
-        d = {
-            s:'tiny', b:'large', h:'larger', r:'largest',
-            e:"Euler's number", p:'pi', t:'tau',
-            i:'Infinity', j:'-Infinity', n:'NaN',
-            }
-        nd = self.loads(self.dumps(d))
-        self.assertEqual(nd[str(SMALL)], 'tiny')
-        self.assertEqual(nd[str(BIG)], 'large')
-        self.assertEqual(nd[str(HUGE)], 'larger')
-        self.assertEqual(nd[str(REALLY_HUGE)], 'largest')
-        self.assertEqual(nd[repr(E)], "Euler's number")
-        self.assertEqual(nd[repr(PI)], 'pi')
-        self.assertEqual(nd[repr(TAU)], 'tau')
-        self.assertEqual(nd['Infinity'], 'Infinity')
-        self.assertEqual(nd['-Infinity'], '-Infinity')
-        self.assertEqual(nd['NaN'], 'NaN')
-
-    def test_dict_values(self):
-        d = dict(
-                tiny=BigNum.small,
-                large=BigNum.big,
-                larger=BigNum.huge,
-                largest=BigNum.really_huge,
-                e=FloatNum.e,
-                pi=FloatNum.pi,
-                tau=FloatNum.tau,
-                i=WierdNum.inf,
-                j=WierdNum.neg_inf,
-                n=WierdNum.nan,
-                )
-        nd = self.loads(self.dumps(d))
-        self.assertEqual(nd['tiny'], SMALL)
-        self.assertEqual(nd['large'], BIG)
-        self.assertEqual(nd['larger'], HUGE)
-        self.assertEqual(nd['largest'], REALLY_HUGE)
-        self.assertEqual(nd['e'], E)
-        self.assertEqual(nd['pi'], PI)
-        self.assertEqual(nd['tau'], TAU)
-        self.assertEqual(nd['i'], INF)
-        self.assertEqual(nd['j'], NEG_INF)
-        self.assertTrue(isnan(nd['n']))
-
-class TestPyEnum(TestEnum, PyTest): pass
-class TestCEnum(TestEnum, CTest): pass

package/python3.6.2/lib/python3.6/test/test_json/test_fail.py

@@ -1,216 +0,0 @@
-from test.test_json import PyTest, CTest
-
-# 2007-10-05
-JSONDOCS = [
-    # http://json.org/JSON_checker/test/fail1.json
-    '"A JSON payload should be an object or array, not a string."',
-    # http://json.org/JSON_checker/test/fail2.json
-    '["Unclosed array"',
-    # http://json.org/JSON_checker/test/fail3.json
-    '{unquoted_key: "keys must be quoted"}',
-    # http://json.org/JSON_checker/test/fail4.json
-    '["extra comma",]',
-    # http://json.org/JSON_checker/test/fail5.json
-    '["double extra comma",,]',
-    # http://json.org/JSON_checker/test/fail6.json
-    '[   , "<-- missing value"]',
-    # http://json.org/JSON_checker/test/fail7.json
-    '["Comma after the close"],',
-    # http://json.org/JSON_checker/test/fail8.json
-    '["Extra close"]]',
-    # http://json.org/JSON_checker/test/fail9.json
-    '{"Extra comma": true,}',
-    # http://json.org/JSON_checker/test/fail10.json
-    '{"Extra value after close": true} "misplaced quoted value"',
-    # http://json.org/JSON_checker/test/fail11.json
-    '{"Illegal expression": 1 + 2}',
-    # http://json.org/JSON_checker/test/fail12.json
-    '{"Illegal invocation": alert()}',
-    # http://json.org/JSON_checker/test/fail13.json
-    '{"Numbers cannot have leading zeroes": 013}',
-    # http://json.org/JSON_checker/test/fail14.json
-    '{"Numbers cannot be hex": 0x14}',
-    # http://json.org/JSON_checker/test/fail15.json
-    '["Illegal backslash escape: \\x15"]',
-    # http://json.org/JSON_checker/test/fail16.json
-    '[\\naked]',
-    # http://json.org/JSON_checker/test/fail17.json
-    '["Illegal backslash escape: \\017"]',
-    # http://json.org/JSON_checker/test/fail18.json
-    '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
-    # http://json.org/JSON_checker/test/fail19.json
-    '{"Missing colon" null}',
-    # http://json.org/JSON_checker/test/fail20.json
-    '{"Double colon":: null}',
-    # http://json.org/JSON_checker/test/fail21.json
-    '{"Comma instead of colon", null}',
-    # http://json.org/JSON_checker/test/fail22.json
-    '["Colon instead of comma": false]',
-    # http://json.org/JSON_checker/test/fail23.json
-    '["Bad value", truth]',
-    # http://json.org/JSON_checker/test/fail24.json
-    "['single quote']",
-    # http://json.org/JSON_checker/test/fail25.json
-    '["\ttab\tcharacter\tin\tstring\t"]',
-    # http://json.org/JSON_checker/test/fail26.json
-    '["tab\\   character\\   in\\  string\\  "]',
-    # http://json.org/JSON_checker/test/fail27.json
-    '["line\nbreak"]',
-    # http://json.org/JSON_checker/test/fail28.json
-    '["line\\\nbreak"]',
-    # http://json.org/JSON_checker/test/fail29.json
-    '[0e]',
-    # http://json.org/JSON_checker/test/fail30.json
-    '[0e+]',
-    # http://json.org/JSON_checker/test/fail31.json
-    '[0e+-1]',
-    # http://json.org/JSON_checker/test/fail32.json
-    '{"Comma instead if closing brace": true,',
-    # http://json.org/JSON_checker/test/fail33.json
-    '["mismatch"}',
-    # http://code.google.com/p/simplejson/issues/detail?id=3
-    '["A\u001FZ control characters in string"]',
-]
-
-SKIPS = {
-    1: "why not have a string payload?",
-    18: "spec doesn't specify any nesting limitations",
-}
-
-class TestFail:
-    def test_failures(self):
-        for idx, doc in enumerate(JSONDOCS):
-            idx = idx + 1
-            if idx in SKIPS:
-                self.loads(doc)
-                continue
-            try:
-                self.loads(doc)
-            except self.JSONDecodeError:
-                pass
-            else:
-                self.fail("Expected failure for fail{0}.json: {1!r}".format(idx, doc))
-
-    def test_non_string_keys_dict(self):
-        data = {'a' : 1, (1, 2) : 2}
-
-        #This is for c encoder
-        self.assertRaises(TypeError, self.dumps, data)
-
-        #This is for python encoder
-        self.assertRaises(TypeError, self.dumps, data, indent=True)
-
-    def test_truncated_input(self):
-        test_cases = [
-            ('', 'Expecting value', 0),
-            ('[', 'Expecting value', 1),
-            ('[42', "Expecting ',' delimiter", 3),
-            ('[42,', 'Expecting value', 4),
-            ('["', 'Unterminated string starting at', 1),
-            ('["spam', 'Unterminated string starting at', 1),
-            ('["spam"', "Expecting ',' delimiter", 7),
-            ('["spam",', 'Expecting value', 8),
-            ('{', 'Expecting property name enclosed in double quotes', 1),
-            ('{"', 'Unterminated string starting at', 1),
-            ('{"spam', 'Unterminated string starting at', 1),
-            ('{"spam"', "Expecting ':' delimiter", 7),
-            ('{"spam":', 'Expecting value', 8),
-            ('{"spam":42', "Expecting ',' delimiter", 10),
-            ('{"spam":42,', 'Expecting property name enclosed in double quotes', 11),
-        ]
-        test_cases += [
-            ('"', 'Unterminated string starting at', 0),
-            ('"spam', 'Unterminated string starting at', 0),
-        ]
-        for data, msg, idx in test_cases:
-            with self.assertRaises(self.JSONDecodeError) as cm:
-                self.loads(data)
-            err = cm.exception
-            self.assertEqual(err.msg, msg)
-            self.assertEqual(err.pos, idx)
-            self.assertEqual(err.lineno, 1)
-            self.assertEqual(err.colno, idx + 1)
-            self.assertEqual(str(err),
-                             '%s: line 1 column %d (char %d)' %
-                             (msg, idx + 1, idx))
-
-    def test_unexpected_data(self):
-        test_cases = [
-            ('[,', 'Expecting value', 1),
-            ('{"spam":[}', 'Expecting value', 9),
-            ('[42:', "Expecting ',' delimiter", 3),
-            ('[42 "spam"', "Expecting ',' delimiter", 4),
-            ('[42,]', 'Expecting value', 4),
-            ('{"spam":[42}', "Expecting ',' delimiter", 11),
-            ('["]', 'Unterminated string starting at', 1),
-            ('["spam":', "Expecting ',' delimiter", 7),
-            ('["spam",]', 'Expecting value', 8),
-            ('{:', 'Expecting property name enclosed in double quotes', 1),
-            ('{,', 'Expecting property name enclosed in double quotes', 1),
-            ('{42', 'Expecting property name enclosed in double quotes', 1),
-            ('[{]', 'Expecting property name enclosed in double quotes', 2),
-            ('{"spam",', "Expecting ':' delimiter", 7),
-            ('{"spam"}', "Expecting ':' delimiter", 7),
-            ('[{"spam"]', "Expecting ':' delimiter", 8),
-            ('{"spam":}', 'Expecting value', 8),
-            ('[{"spam":]', 'Expecting value', 9),
-            ('{"spam":42 "ham"', "Expecting ',' delimiter", 11),
-            ('[{"spam":42]', "Expecting ',' delimiter", 11),
-            ('{"spam":42,}', 'Expecting property name enclosed in double quotes', 11),
-        ]
-        for data, msg, idx in test_cases:
-            with self.assertRaises(self.JSONDecodeError) as cm:
-                self.loads(data)
-            err = cm.exception
-            self.assertEqual(err.msg, msg)
-            self.assertEqual(err.pos, idx)
-            self.assertEqual(err.lineno, 1)
-            self.assertEqual(err.colno, idx + 1)
-            self.assertEqual(str(err),
-                             '%s: line 1 column %d (char %d)' %
-                             (msg, idx + 1, idx))
-
-    def test_extra_data(self):
-        test_cases = [
-            ('[]]', 'Extra data', 2),
-            ('{}}', 'Extra data', 2),
-            ('[],[]', 'Extra data', 2),
-            ('{},{}', 'Extra data', 2),
-        ]
-        test_cases += [
-            ('42,"spam"', 'Extra data', 2),
-            ('"spam",42', 'Extra data', 6),
-        ]
-        for data, msg, idx in test_cases:
-            with self.assertRaises(self.JSONDecodeError) as cm:
-                self.loads(data)
-            err = cm.exception
-            self.assertEqual(err.msg, msg)
-            self.assertEqual(err.pos, idx)
-            self.assertEqual(err.lineno, 1)
-            self.assertEqual(err.colno, idx + 1)
-            self.assertEqual(str(err),
-                             '%s: line 1 column %d (char %d)' %
-                             (msg, idx + 1, idx))
-
-    def test_linecol(self):
-        test_cases = [
-            ('!', 1, 1, 0),
-            (' !', 1, 2, 1),
-            ('\n!', 2, 1, 1),
-            ('\n  \n\n     !', 4, 6, 10),
-        ]
-        for data, line, col, idx in test_cases:
-            with self.assertRaises(self.JSONDecodeError) as cm:
-                self.loads(data)
-            err = cm.exception
-            self.assertEqual(err.msg, 'Expecting value')
-            self.assertEqual(err.pos, idx)
-            self.assertEqual(err.lineno, line)
-            self.assertEqual(err.colno, col)
-            self.assertEqual(str(err),
-                             'Expecting value: line %s column %d (char %d)' %
-                             (line, col, idx))
-
-class TestPyFail(TestFail, PyTest): pass
-class TestCFail(TestFail, CTest): pass

package/python3.6.2/lib/python3.6/test/test_json/test_float.py

@@ -1,33 +0,0 @@
-import math
-from test.test_json import PyTest, CTest
-
-
-class TestFloat:
-    def test_floats(self):
-        for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]:
-            self.assertEqual(float(self.dumps(num)), num)
-            self.assertEqual(self.loads(self.dumps(num)), num)
-
-    def test_ints(self):
-        for num in [1, 1<<32, 1<<64]:
-            self.assertEqual(self.dumps(num), str(num))
-            self.assertEqual(int(self.dumps(num)), num)
-
-    def test_out_of_range(self):
-        self.assertEqual(self.loads('[23456789012E666]'), [float('inf')])
-        self.assertEqual(self.loads('[-23456789012E666]'), [float('-inf')])
-
-    def test_allow_nan(self):
-        for val in (float('inf'), float('-inf'), float('nan')):
-            out = self.dumps([val])
-            if val == val:  # inf
-                self.assertEqual(self.loads(out), [val])
-            else:  # nan
-                res = self.loads(out)
-                self.assertEqual(len(res), 1)
-                self.assertNotEqual(res[0], res[0])
-            self.assertRaises(ValueError, self.dumps, [val], allow_nan=False)
-
-
-class TestPyFloat(TestFloat, PyTest): pass
-class TestCFloat(TestFloat, CTest): pass