ꦫꦣꦺꦤ꧀ꦄꦤ꧀ꦠꦱꦺꦤ

PATH: opt / bitninja-python-dojo / embedded / lib / python3.9 / test

# -*- coding: utf-8 -*-

import collections
import io
import itertools
import pprint
import random
import test.support
import test.test_set
import types
import unittest

# list, tuple and dict subclasses that do or don't overwrite __repr__
class list2(list):
    pass

class list3(list):
    def __repr__(self):
        return list.__repr__(self)

class tuple2(tuple):
    pass

class tuple3(tuple):
    def __repr__(self):
        return tuple.__repr__(self)

class set2(set):
    pass

class set3(set):
    def __repr__(self):
        return set.__repr__(self)

class frozenset2(frozenset):
    pass

class frozenset3(frozenset):
    def __repr__(self):
        return frozenset.__repr__(self)

class dict2(dict):
    pass

class dict3(dict):
    def __repr__(self):
        return dict.__repr__(self)

class Unorderable:
    def __repr__(self):
        return str(id(self))

# Class Orderable is orderable with any type
class Orderable:
    def __init__(self, hash):
        self._hash = hash
    def __lt__(self, other):
        return False
    def __gt__(self, other):
        return self != other
    def __le__(self, other):
        return self == other
    def __ge__(self, other):
        return True
    def __eq__(self, other):
        return self is other
    def __ne__(self, other):
        return self is not other
    def __hash__(self):
        return self._hash

class QueryTestCase(unittest.TestCase):

def setUp(self):
        self.a = list(range(100))
        self.b = list(range(200))
        self.a[-12] = self.b

def test_init(self):
        pp = pprint.PrettyPrinter()
        pp = pprint.PrettyPrinter(indent=4, width=40, depth=5,
                                  stream=io.StringIO(), compact=True)
        pp = pprint.PrettyPrinter(4, 40, 5, io.StringIO())
        pp = pprint.PrettyPrinter(sort_dicts=False)
        with self.assertRaises(TypeError):
            pp = pprint.PrettyPrinter(4, 40, 5, io.StringIO(), True)
        self.assertRaises(ValueError, pprint.PrettyPrinter, indent=-1)
        self.assertRaises(ValueError, pprint.PrettyPrinter, depth=0)
        self.assertRaises(ValueError, pprint.PrettyPrinter, depth=-1)
        self.assertRaises(ValueError, pprint.PrettyPrinter, width=0)

def test_basic(self):
        # Verify .isrecursive() and .isreadable() w/o recursion
        pp = pprint.PrettyPrinter()
        for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, b"def",
                     bytearray(b"ghi"), True, False, None, ...,
                     self.a, self.b):
            # module-level convenience functions
            self.assertFalse(pprint.isrecursive(safe),
                             "expected not isrecursive for %r" % (safe,))
            self.assertTrue(pprint.isreadable(safe),
                            "expected isreadable for %r" % (safe,))
            # PrettyPrinter methods
            self.assertFalse(pp.isrecursive(safe),
                             "expected not isrecursive for %r" % (safe,))
            self.assertTrue(pp.isreadable(safe),
                            "expected isreadable for %r" % (safe,))

def test_knotted(self):
        # Verify .isrecursive() and .isreadable() w/ recursion
        # Tie a knot.
        self.b[67] = self.a
        # Messy dict.
        self.d = {}
        self.d[0] = self.d[1] = self.d[2] = self.d

pp = pprint.PrettyPrinter()

for icky in self.a, self.b, self.d, (self.d, self.d):
            self.assertTrue(pprint.isrecursive(icky), "expected isrecursive")
            self.assertFalse(pprint.isreadable(icky), "expected not isreadable")
            self.assertTrue(pp.isrecursive(icky), "expected isrecursive")
            self.assertFalse(pp.isreadable(icky), "expected not isreadable")

# Break the cycles.
        self.d.clear()
        del self.a[:]
        del self.b[:]

for safe in self.a, self.b, self.d, (self.d, self.d):
            # module-level convenience functions
            self.assertFalse(pprint.isrecursive(safe),
                             "expected not isrecursive for %r" % (safe,))
            self.assertTrue(pprint.isreadable(safe),
                            "expected isreadable for %r" % (safe,))
            # PrettyPrinter methods
            self.assertFalse(pp.isrecursive(safe),
                             "expected not isrecursive for %r" % (safe,))
            self.assertTrue(pp.isreadable(safe),
                            "expected isreadable for %r" % (safe,))

def test_unreadable(self):
        # Not recursive but not readable anyway
        pp = pprint.PrettyPrinter()
        for unreadable in type(3), pprint, pprint.isrecursive:
            # module-level convenience functions
            self.assertFalse(pprint.isrecursive(unreadable),
                             "expected not isrecursive for %r" % (unreadable,))
            self.assertFalse(pprint.isreadable(unreadable),
                             "expected not isreadable for %r" % (unreadable,))
            # PrettyPrinter methods
            self.assertFalse(pp.isrecursive(unreadable),
                             "expected not isrecursive for %r" % (unreadable,))
            self.assertFalse(pp.isreadable(unreadable),
                             "expected not isreadable for %r" % (unreadable,))

def test_same_as_repr(self):
        # Simple objects, small containers and classes that overwrite __repr__
        # For those the result should be the same as repr().
        # Ahem.  The docs don't say anything about that -- this appears to
        # be testing an implementation quirk.  Starting in Python 2.5, it's
        # not true for dicts:  pprint always sorts dicts by key now; before,
        # it sorted a dict display if and only if the display required
        # multiple lines.  For that reason, dicts with more than one element
        # aren't tested here.
        for simple in (0, 0, 0+0j, 0.0, "", b"", bytearray(),
                       (), tuple2(), tuple3(),
                       [], list2(), list3(),
                       set(), set2(), set3(),
                       frozenset(), frozenset2(), frozenset3(),
                       {}, dict2(), dict3(),
                       self.assertTrue, pprint,
                       -6, -6, -6-6j, -1.5, "x", b"x", bytearray(b"x"),
                       (3,), [3], {3: 6},
                       (1,2), [3,4], {5: 6},
                       tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
                       [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
                       set({7}), set2({7}), set3({7}),
                       frozenset({8}), frozenset2({8}), frozenset3({8}),
                       dict2({5: 6}), dict3({5: 6}),
                       range(10, -11, -1),
                       True, False, None, ...,
                      ):
            native = repr(simple)
            self.assertEqual(pprint.pformat(simple), native)
            self.assertEqual(pprint.pformat(simple, width=1, indent=0)
                             .replace('\n', ' '), native)
            self.assertEqual(pprint.saferepr(simple), native)

def test_basic_line_wrap(self):
        # verify basic line-wrapping operation
        o = {'RPM_cal': 0,
             'RPM_cal2': 48059,
             'Speed_cal': 0,
             'controldesk_runtime_us': 0,
             'main_code_runtime_us': 0,
             'read_io_runtime_us': 0,
             'write_io_runtime_us': 43690}
        exp = """\
{'RPM_cal': 0,
 'RPM_cal2': 48059,
 'Speed_cal': 0,
 'controldesk_runtime_us': 0,
 'main_code_runtime_us': 0,
 'read_io_runtime_us': 0,
 'write_io_runtime_us': 43690}"""
        for type in [dict, dict2]:
            self.assertEqual(pprint.pformat(type(o)), exp)

o = range(100)
        exp = '[%s]' % ',\n '.join(map(str, o))
        for type in [list, list2]:
            self.assertEqual(pprint.pformat(type(o)), exp)

o = tuple(range(100))
        exp = '(%s)' % ',\n '.join(map(str, o))
        for type in [tuple, tuple2]:
            self.assertEqual(pprint.pformat(type(o)), exp)

# indent parameter
        o = range(100)
        exp = '[   %s]' % ',\n    '.join(map(str, o))
        for type in [list, list2]:
            self.assertEqual(pprint.pformat(type(o), indent=4), exp)

def test_nested_indentations(self):
        o1 = list(range(10))
        o2 = dict(first=1, second=2, third=3)
        o = [o1, o2]
        expected = """\
[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {'first': 1, 'second': 2, 'third': 3}]"""
        self.assertEqual(pprint.pformat(o, indent=4, width=42), expected)
        expected = """\
[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {   'first': 1,
        'second': 2,
        'third': 3}]"""
        self.assertEqual(pprint.pformat(o, indent=4, width=41), expected)

def test_width(self):
        expected = """\
[[[[[[1, 2, 3],
     '1 2']]]],
 {1: [1, 2, 3],
  2: [12, 34]},
 'abc def ghi',
 ('ab cd ef',),
 set2({1, 23}),
 [[[[[1, 2, 3],
     '1 2']]]]]"""
        o = eval(expected)
        self.assertEqual(pprint.pformat(o, width=15), expected)
        self.assertEqual(pprint.pformat(o, width=16), expected)
        self.assertEqual(pprint.pformat(o, width=25), expected)
        self.assertEqual(pprint.pformat(o, width=14), """\
[[[[[[1,
      2,
      3],
     '1 '
     '2']]]],
 {1: [1,
      2,
      3],
  2: [12,
      34]},
 'abc def '
 'ghi',
 ('ab cd '
  'ef',),
 set2({1,
       23}),
 [[[[[1,
      2,
      3],
     '1 '
     '2']]]]]""")

def test_sorted_dict(self):
        # Starting in Python 2.5, pprint sorts dict displays by key regardless
        # of how small the dictionary may be.
        # Before the change, on 32-bit Windows pformat() gave order
        # 'a', 'c', 'b' here, so this test failed.
        d = {'a': 1, 'b': 1, 'c': 1}
        self.assertEqual(pprint.pformat(d), "{'a': 1, 'b': 1, 'c': 1}")
        self.assertEqual(pprint.pformat([d, d]),
            "[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]")

# The next one is kind of goofy.  The sorted order depends on the
        # alphabetic order of type names:  "int" < "str" < "tuple".  Before
        # Python 2.5, this was in the test_same_as_repr() test.  It's worth
        # keeping around for now because it's one of few tests of pprint
        # against a crazy mix of types.
        self.assertEqual(pprint.pformat({"xy\tab\n": (3,), 5: [[]], (): {}}),
            r"{5: [[]], 'xy\tab\n': (3,), (): {}}")

def test_sort_dict(self):
        d = dict.fromkeys('cba')
        self.assertEqual(pprint.pformat(d, sort_dicts=False), "{'c': None, 'b': None, 'a': None}")
        self.assertEqual(pprint.pformat([d, d], sort_dicts=False),
            "[{'c': None, 'b': None, 'a': None}, {'c': None, 'b': None, 'a': None}]")

def test_ordered_dict(self):
        d = collections.OrderedDict()
        self.assertEqual(pprint.pformat(d, width=1), 'OrderedDict()')
        d = collections.OrderedDict([])
        self.assertEqual(pprint.pformat(d, width=1), 'OrderedDict()')
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.OrderedDict(zip(words, itertools.count()))
        self.assertEqual(pprint.pformat(d),
"""\
OrderedDict([('the', 0),
             ('quick', 1),
             ('brown', 2),
             ('fox', 3),
             ('jumped', 4),
             ('over', 5),
             ('a', 6),
             ('lazy', 7),
             ('dog', 8)])""")

def test_mapping_proxy(self):
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = dict(zip(words, itertools.count()))
        m = types.MappingProxyType(d)
        self.assertEqual(pprint.pformat(m), """\
mappingproxy({'a': 6,
              'brown': 2,
              'dog': 8,
              'fox': 3,
              'jumped': 4,
              'lazy': 7,
              'over': 5,
              'quick': 1,
              'the': 0})""")
        d = collections.OrderedDict(zip(words, itertools.count()))
        m = types.MappingProxyType(d)
        self.assertEqual(pprint.pformat(m), """\
mappingproxy(OrderedDict([('the', 0),
                          ('quick', 1),
                          ('brown', 2),
                          ('fox', 3),
                          ('jumped', 4),
                          ('over', 5),
                          ('a', 6),
                          ('lazy', 7),
                          ('dog', 8)]))""")

def test_empty_simple_namespace(self):
        ns = types.SimpleNamespace()
        formatted = pprint.pformat(ns)
        self.assertEqual(formatted, "namespace()")

def test_small_simple_namespace(self):
        ns = types.SimpleNamespace(a=1, b=2)
        formatted = pprint.pformat(ns)
        self.assertEqual(formatted, "namespace(a=1, b=2)")

def test_simple_namespace(self):
        ns = types.SimpleNamespace(
            the=0,
            quick=1,
            brown=2,
            fox=3,
            jumped=4,
            over=5,
            a=6,
            lazy=7,
            dog=8,
        )
        formatted = pprint.pformat(ns, width=60)
        self.assertEqual(formatted, """\
namespace(the=0,
          quick=1,
          brown=2,
          fox=3,
          jumped=4,
          over=5,
          a=6,
          lazy=7,
          dog=8)""")

def test_simple_namespace_subclass(self):
        class AdvancedNamespace(types.SimpleNamespace): pass
        ns = AdvancedNamespace(
            the=0,
            quick=1,
            brown=2,
            fox=3,
            jumped=4,
            over=5,
            a=6,
            lazy=7,
            dog=8,
        )
        formatted = pprint.pformat(ns, width=60)
        self.assertEqual(formatted, """\
AdvancedNamespace(the=0,
                  quick=1,
                  brown=2,
                  fox=3,
                  jumped=4,
                  over=5,
                  a=6,
                  lazy=7,
                  dog=8)""")

def test_subclassing(self):
        o = {'names with spaces': 'should be presented using repr()',
             'others.should.not.be': 'like.this'}
        exp = """\
{'names with spaces': 'should be presented using repr()',
 others.should.not.be: like.this}"""
        self.assertEqual(DottedPrettyPrinter().pformat(o), exp)

def test_set_reprs(self):
        self.assertEqual(pprint.pformat(set()), 'set()')
        self.assertEqual(pprint.pformat(set(range(3))), '{0, 1, 2}')
        self.assertEqual(pprint.pformat(set(range(7)), width=20), '''\
{0,
 1,
 2,
 3,
 4,
 5,
 6}''')
        self.assertEqual(pprint.pformat(set2(range(7)), width=20), '''\
set2({0,
      1,
      2,
      3,
      4,
      5,
      6})''')
        self.assertEqual(pprint.pformat(set3(range(7)), width=20),
                         'set3({0, 1, 2, 3, 4, 5, 6})')

self.assertEqual(pprint.pformat(frozenset()), 'frozenset()')
        self.assertEqual(pprint.pformat(frozenset(range(3))),
                         'frozenset({0, 1, 2})')
        self.assertEqual(pprint.pformat(frozenset(range(7)), width=20), '''\
frozenset({0,
           1,
           2,
           3,
           4,
           5,
           6})''')
        self.assertEqual(pprint.pformat(frozenset2(range(7)), width=20), '''\
frozenset2({0,
            1,
            2,
            3,
            4,
            5,
            6})''')
        self.assertEqual(pprint.pformat(frozenset3(range(7)), width=20),
                         'frozenset3({0, 1, 2, 3, 4, 5, 6})')

@unittest.expectedFailure
    #See http://bugs.python.org/issue13907
    @test.support.cpython_only
    def test_set_of_sets_reprs(self):
        # This test creates a complex arrangement of frozensets and
        # compares the pretty-printed repr against a string hard-coded in
        # the test.  The hard-coded repr depends on the sort order of
        # frozensets.
        #
        # However, as the docs point out: "Since sets only define
        # partial ordering (subset relationships), the output of the
        # list.sort() method is undefined for lists of sets."
        #
        # In a nutshell, the test assumes frozenset({0}) will always
        # sort before frozenset({1}), but:
        #
        # >>> frozenset({0}) < frozenset({1})
        # False
        # >>> frozenset({1}) < frozenset({0})
        # False
        #
        # Consequently, this test is fragile and
        # implementation-dependent.  Small changes to Python's sort
        # algorithm cause the test to fail when it should pass.
        # XXX Or changes to the dictionary implementation...

cube_repr_tgt = """\
{frozenset(): frozenset({frozenset({2}), frozenset({0}), frozenset({1})}),
 frozenset({0}): frozenset({frozenset(),
                            frozenset({0, 2}),
                            frozenset({0, 1})}),
 frozenset({1}): frozenset({frozenset(),
                            frozenset({1, 2}),
                            frozenset({0, 1})}),
 frozenset({2}): frozenset({frozenset(),
                            frozenset({1, 2}),
                            frozenset({0, 2})}),
 frozenset({1, 2}): frozenset({frozenset({2}),
                               frozenset({1}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 2}): frozenset({frozenset({2}),
                               frozenset({0}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 1}): frozenset({frozenset({0}),
                               frozenset({1}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 1, 2}): frozenset({frozenset({1, 2}),
                                  frozenset({0, 2}),
                                  frozenset({0, 1})})}"""
        cube = test.test_set.cube(3)
        self.assertEqual(pprint.pformat(cube), cube_repr_tgt)
        cubo_repr_tgt = """\
{frozenset({frozenset({0, 2}), frozenset({0})}): frozenset({frozenset({frozenset({0,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  1})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({0})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({0,
                                                                                  2})})}),
 frozenset({frozenset({0, 1}), frozenset({1})}): frozenset({frozenset({frozenset({0,
                                                                                  1}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  1})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({1})})}),
 frozenset({frozenset({1, 2}), frozenset({1})}): frozenset({frozenset({frozenset({1,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({1})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({0,
                                                                                  1})})}),
 frozenset({frozenset({1, 2}), frozenset({2})}): frozenset({frozenset({frozenset({1,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({2})})}),
 frozenset({frozenset(), frozenset({0})}): frozenset({frozenset({frozenset({0}),
                                                                 frozenset({0,
                                                                            1})}),
                                                      frozenset({frozenset({0}),
                                                                 frozenset({0,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({1})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({2})})}),
 frozenset({frozenset(), frozenset({1})}): frozenset({frozenset({frozenset(),
                                                                 frozenset({0})}),
                                                      frozenset({frozenset({1}),
                                                                 frozenset({1,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({2})}),
                                                      frozenset({frozenset({1}),
                                                                 frozenset({0,
                                                                            1})})}),
 frozenset({frozenset({2}), frozenset()}): frozenset({frozenset({frozenset({2}),
                                                                 frozenset({1,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({0})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({1})}),
                                                      frozenset({frozenset({2}),
                                                                 frozenset({0,
                                                                            2})})}),
 frozenset({frozenset({0, 1, 2}), frozenset({0, 1})}): frozenset({frozenset({frozenset({1,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0}),
                                                                             frozenset({0,
                                                                                        1})}),
                                                                  frozenset({frozenset({1}),
                                                                             frozenset({0,
                                                                                        1})})}),
 frozenset({frozenset({0}), frozenset({0, 1})}): frozenset({frozenset({frozenset(),
                                                                       frozenset({0})}),
                                                            frozenset({frozenset({0,
                                                                                  1}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({0,
                                                                                  1})})}),
 frozenset({frozenset({2}), frozenset({0, 2})}): frozenset({frozenset({frozenset({0,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({2})})}),
 frozenset({frozenset({0, 1, 2}), frozenset({0, 2})}): frozenset({frozenset({frozenset({1,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        1}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0}),
                                                                             frozenset({0,
                                                                                        2})}),
                                                                  frozenset({frozenset({2}),
                                                                             frozenset({0,
                                                                                        2})})}),
 frozenset({frozenset({1, 2}), frozenset({0, 1, 2})}): frozenset({frozenset({frozenset({0,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        1}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({2}),
                                                                             frozenset({1,
                                                                                        2})}),
                                                                  frozenset({frozenset({1}),
                                                                             frozenset({1,
                                                                                        2})})})}"""

cubo = test.test_set.linegraph(cube)
        self.assertEqual(pprint.pformat(cubo), cubo_repr_tgt)

def test_depth(self):
        nested_tuple = (1, (2, (3, (4, (5, 6)))))
        nested_dict = {1: {2: {3: {4: {5: {6: 6}}}}}}
        nested_list = [1, [2, [3, [4, [5, [6, []]]]]]]
        self.assertEqual(pprint.pformat(nested_tuple), repr(nested_tuple))
        self.assertEqual(pprint.pformat(nested_dict), repr(nested_dict))
        self.assertEqual(pprint.pformat(nested_list), repr(nested_list))

lv1_tuple = '(1, (...))'
        lv1_dict = '{1: {...}}'
        lv1_list = '[1, [...]]'
        self.assertEqual(pprint.pformat(nested_tuple, depth=1), lv1_tuple)
        self.assertEqual(pprint.pformat(nested_dict, depth=1), lv1_dict)
        self.assertEqual(pprint.pformat(nested_list, depth=1), lv1_list)

def test_sort_unorderable_values(self):
        # Issue 3976:  sorted pprints fail for unorderable values.
        n = 20
        keys = [Unorderable() for i in range(n)]
        random.shuffle(keys)
        skeys = sorted(keys, key=id)
        clean = lambda s: s.replace(' ', '').replace('\n','')

self.assertEqual(clean(pprint.pformat(set(keys))),
            '{' + ','.join(map(repr, skeys)) + '}')
        self.assertEqual(clean(pprint.pformat(frozenset(keys))),
            'frozenset({' + ','.join(map(repr, skeys)) + '})')
        self.assertEqual(clean(pprint.pformat(dict.fromkeys(keys))),
            '{' + ','.join('%r:None' % k for k in skeys) + '}')

# Issue 10017: TypeError on user-defined types as dict keys.
        self.assertEqual(pprint.pformat({Unorderable: 0, 1: 0}),
                         '{1: 0, ' + repr(Unorderable) +': 0}')

# Issue 14998: TypeError on tuples with NoneTypes as dict keys.
        keys = [(1,), (None,)]
        self.assertEqual(pprint.pformat(dict.fromkeys(keys, 0)),
                         '{%r: 0, %r: 0}' % tuple(sorted(keys, key=id)))

def test_sort_orderable_and_unorderable_values(self):
        # Issue 22721:  sorted pprints is not stable
        a = Unorderable()
        b = Orderable(hash(a))  # should have the same hash value
        # self-test
        self.assertLess(a, b)
        self.assertLess(str(type(b)), str(type(a)))
        self.assertEqual(sorted([b, a]), [a, b])
        self.assertEqual(sorted([a, b]), [a, b])
        # set
        self.assertEqual(pprint.pformat(set([b, a]), width=1),
                         '{%r,\n %r}' % (a, b))
        self.assertEqual(pprint.pformat(set([a, b]), width=1),
                         '{%r,\n %r}' % (a, b))
        # dict
        self.assertEqual(pprint.pformat(dict.fromkeys([b, a]), width=1),
                         '{%r: None,\n %r: None}' % (a, b))
        self.assertEqual(pprint.pformat(dict.fromkeys([a, b]), width=1),
                         '{%r: None,\n %r: None}' % (a, b))

def test_str_wrap(self):
        # pprint tries to wrap strings intelligently
        fox = 'the quick brown fox jumped over a lazy dog'
        self.assertEqual(pprint.pformat(fox, width=19), """\
('the quick brown '
 'fox jumped over '
 'a lazy dog')""")
        self.assertEqual(pprint.pformat({'a': 1, 'b': fox, 'c': 2},
                                        width=25), """\
{'a': 1,
 'b': 'the quick brown '
      'fox jumped over '
      'a lazy dog',
 'c': 2}""")
        # With some special characters
        # - \n always triggers a new line in the pprint
        # - \t and \n are escaped
        # - non-ASCII is allowed
        # - an apostrophe doesn't disrupt the pprint
        special = "Portons dix bons \"whiskys\"\nà l'avocat goujat\t qui fumait au zoo"
        self.assertEqual(pprint.pformat(special, width=68), repr(special))
        self.assertEqual(pprint.pformat(special, width=31), """\
('Portons dix bons "whiskys"\\n'
 "à l'avocat goujat\\t qui "
 'fumait au zoo')""")
        self.assertEqual(pprint.pformat(special, width=20), """\
('Portons dix bons '
 '"whiskys"\\n'
 "à l'avocat "
 'goujat\\t qui '
 'fumait au zoo')""")
        self.assertEqual(pprint.pformat([[[[[special]]]]], width=35), """\
[[[[['Portons dix bons "whiskys"\\n'
     "à l'avocat goujat\\t qui "
     'fumait au zoo']]]]]""")
        self.assertEqual(pprint.pformat([[[[[special]]]]], width=25), """\
[[[[['Portons dix bons '
     '"whiskys"\\n'
     "à l'avocat "
     'goujat\\t qui '
     'fumait au zoo']]]]]""")
        self.assertEqual(pprint.pformat([[[[[special]]]]], width=23), """\
[[[[['Portons dix '
     'bons "whiskys"\\n'
     "à l'avocat "
     'goujat\\t qui '
     'fumait au '
     'zoo']]]]]""")
        # An unwrappable string is formatted as its repr
        unwrappable = "x" * 100
        self.assertEqual(pprint.pformat(unwrappable, width=80), repr(unwrappable))
        self.assertEqual(pprint.pformat(''), "''")
        # Check that the pprint is a usable repr
        special *= 10
        for width in range(3, 40):
            formatted = pprint.pformat(special, width=width)
            self.assertEqual(eval(formatted), special)
            formatted = pprint.pformat([special] * 2, width=width)
            self.assertEqual(eval(formatted), [special] * 2)

def test_compact(self):
        o = ([list(range(i * i)) for i in range(5)] +
             [list(range(i)) for i in range(6)])
        expected = """\
[[], [0], [0, 1, 2, 3],
 [0, 1, 2, 3, 4, 5, 6, 7, 8],
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
  14, 15],
 [], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3],
 [0, 1, 2, 3, 4]]"""
        self.assertEqual(pprint.pformat(o, width=47, compact=True), expected)

def test_compact_width(self):
        levels = 20
        number = 10
        o = [0] * number
        for i in range(levels - 1):
            o = [o]
        for w in range(levels * 2 + 1, levels + 3 * number - 1):
            lines = pprint.pformat(o, width=w, compact=True).splitlines()
            maxwidth = max(map(len, lines))
            self.assertLessEqual(maxwidth, w)
            self.assertGreater(maxwidth, w - 3)

def test_bytes_wrap(self):
        self.assertEqual(pprint.pformat(b'', width=1), "b''")
        self.assertEqual(pprint.pformat(b'abcd', width=1), "b'abcd'")
        letters = b'abcdefghijklmnopqrstuvwxyz'
        self.assertEqual(pprint.pformat(letters, width=29), repr(letters))
        self.assertEqual(pprint.pformat(letters, width=19), """\
(b'abcdefghijkl'
 b'mnopqrstuvwxyz')""")
        self.assertEqual(pprint.pformat(letters, width=18), """\
(b'abcdefghijkl'
 b'mnopqrstuvwx'
 b'yz')""")
        self.assertEqual(pprint.pformat(letters, width=16), """\
(b'abcdefghijkl'
 b'mnopqrstuvwx'
 b'yz')""")
        special = bytes(range(16))
        self.assertEqual(pprint.pformat(special, width=61), repr(special))
        self.assertEqual(pprint.pformat(special, width=48), """\
(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b'
 b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat(special, width=32), """\
(b'\\x00\\x01\\x02\\x03'
 b'\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b'
 b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat(special, width=1), """\
(b'\\x00\\x01\\x02\\x03'
 b'\\x04\\x05\\x06\\x07'
 b'\\x08\\t\\n\\x0b'
 b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=21), """\
{'a': 1,
 'b': b'abcdefghijkl'
      b'mnopqrstuvwx'
      b'yz',
 'c': 2}""")
        self.assertEqual(pprint.pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=20), """\
{'a': 1,
 'b': b'abcdefgh'
      b'ijklmnop'
      b'qrstuvwxyz',
 'c': 2}""")
        self.assertEqual(pprint.pformat([[[[[[letters]]]]]], width=25), """\
[[[[[[b'abcdefghijklmnop'
      b'qrstuvwxyz']]]]]]""")
        self.assertEqual(pprint.pformat([[[[[[special]]]]]], width=41), """\
[[[[[[b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07'
      b'\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f']]]]]]""")
        # Check that the pprint is a usable repr
        for width in range(1, 64):
            formatted = pprint.pformat(special, width=width)
            self.assertEqual(eval(formatted), special)
            formatted = pprint.pformat([special] * 2, width=width)
            self.assertEqual(eval(formatted), [special] * 2)

def test_bytearray_wrap(self):
        self.assertEqual(pprint.pformat(bytearray(), width=1), "bytearray(b'')")
        letters = bytearray(b'abcdefghijklmnopqrstuvwxyz')
        self.assertEqual(pprint.pformat(letters, width=40), repr(letters))
        self.assertEqual(pprint.pformat(letters, width=28), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwxyz')""")
        self.assertEqual(pprint.pformat(letters, width=27), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwx'
          b'yz')""")
        self.assertEqual(pprint.pformat(letters, width=25), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwx'
          b'yz')""")
        special = bytearray(range(16))
        self.assertEqual(pprint.pformat(special, width=72), repr(special))
        self.assertEqual(pprint.pformat(special, width=57), """\
bytearray(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b'
          b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat(special, width=41), """\
bytearray(b'\\x00\\x01\\x02\\x03'
          b'\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b'
          b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat(special, width=1), """\
bytearray(b'\\x00\\x01\\x02\\x03'
          b'\\x04\\x05\\x06\\x07'
          b'\\x08\\t\\n\\x0b'
          b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(pprint.pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=31), """\
{'a': 1,
 'b': bytearray(b'abcdefghijkl'
                b'mnopqrstuvwx'
                b'yz'),
 'c': 2}""")
        self.assertEqual(pprint.pformat([[[[[letters]]]]], width=37), """\
[[[[[bytearray(b'abcdefghijklmnop'
               b'qrstuvwxyz')]]]]]""")
        self.assertEqual(pprint.pformat([[[[[special]]]]], width=50), """\
[[[[[bytearray(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07'
               b'\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f')]]]]]""")

def test_default_dict(self):
        d = collections.defaultdict(int)
        self.assertEqual(pprint.pformat(d, width=1), "defaultdict(<class 'int'>, {})")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.defaultdict(int, zip(words, itertools.count()))
        self.assertEqual(pprint.pformat(d),
"""\
defaultdict(<class 'int'>,
            {'a': 6,
             'brown': 2,
             'dog': 8,
             'fox': 3,
             'jumped': 4,
             'lazy': 7,
             'over': 5,
             'quick': 1,
             'the': 0})""")

def test_counter(self):
        d = collections.Counter()
        self.assertEqual(pprint.pformat(d, width=1), "Counter()")
        d = collections.Counter('senselessness')
        self.assertEqual(pprint.pformat(d, width=40),
"""\
Counter({'s': 6,
         'e': 4,
         'n': 2,
         'l': 1})""")

def test_chainmap(self):
        d = collections.ChainMap()
        self.assertEqual(pprint.pformat(d, width=1), "ChainMap({})")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        items = list(zip(words, itertools.count()))
        d = collections.ChainMap(dict(items))
        self.assertEqual(pprint.pformat(d),
"""\
ChainMap({'a': 6,
          'brown': 2,
          'dog': 8,
          'fox': 3,
          'jumped': 4,
          'lazy': 7,
          'over': 5,
          'quick': 1,
          'the': 0})""")
        d = collections.ChainMap(dict(items), collections.OrderedDict(items))
        self.assertEqual(pprint.pformat(d),
"""\
ChainMap({'a': 6,
          'brown': 2,
          'dog': 8,
          'fox': 3,
          'jumped': 4,
          'lazy': 7,
          'over': 5,
          'quick': 1,
          'the': 0},
         OrderedDict([('the', 0),
                      ('quick', 1),
                      ('brown', 2),
                      ('fox', 3),
                      ('jumped', 4),
                      ('over', 5),
                      ('a', 6),
                      ('lazy', 7),
                      ('dog', 8)]))""")

def test_deque(self):
        d = collections.deque()
        self.assertEqual(pprint.pformat(d, width=1), "deque([])")
        d = collections.deque(maxlen=7)
        self.assertEqual(pprint.pformat(d, width=1), "deque([], maxlen=7)")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.deque(zip(words, itertools.count()))
        self.assertEqual(pprint.pformat(d),
"""\
deque([('the', 0),
       ('quick', 1),
       ('brown', 2),
       ('fox', 3),
       ('jumped', 4),
       ('over', 5),
       ('a', 6),
       ('lazy', 7),
       ('dog', 8)])""")
        d = collections.deque(zip(words, itertools.count()), maxlen=7)
        self.assertEqual(pprint.pformat(d),
"""\
deque([('brown', 2),
       ('fox', 3),
       ('jumped', 4),
       ('over', 5),
       ('a', 6),
       ('lazy', 7),
       ('dog', 8)],
      maxlen=7)""")

def test_user_dict(self):
        d = collections.UserDict()
        self.assertEqual(pprint.pformat(d, width=1), "{}")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.UserDict(zip(words, itertools.count()))
        self.assertEqual(pprint.pformat(d),
"""\
{'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0}""")

def test_user_list(self):
        d = collections.UserList()
        self.assertEqual(pprint.pformat(d, width=1), "[]")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.UserList(zip(words, itertools.count()))
        self.assertEqual(pprint.pformat(d),
"""\
[('the', 0),
 ('quick', 1),
 ('brown', 2),
 ('fox', 3),
 ('jumped', 4),
 ('over', 5),
 ('a', 6),
 ('lazy', 7),
 ('dog', 8)]""")

def test_user_string(self):
        d = collections.UserString('')
        self.assertEqual(pprint.pformat(d, width=1), "''")
        d = collections.UserString('the quick brown fox jumped over a lazy dog')
        self.assertEqual(pprint.pformat(d, width=20),
"""\
('the quick brown '
 'fox jumped over '
 'a lazy dog')""")
        self.assertEqual(pprint.pformat({1: d}, width=20),
"""\
{1: 'the quick '
    'brown fox '
    'jumped over a '
    'lazy dog'}""")

class DottedPrettyPrinter(pprint.PrettyPrinter):

def format(self, object, context, maxlevels, level):
        if isinstance(object, str):
            if ' ' in object:
                return repr(object), 1, 0
            else:
                return object, 0, 0
        else:
            return pprint.PrettyPrinter.format(
                self, object, context, maxlevels, level)

if __name__ == "__main__":
    unittest.main()

[+] ..
[-] test_largefile.py [edit]
[-] test_set.py [edit]
[-] test_sunau.py [edit]
[-] test_webbrowser.py [edit]
[-] test_idle.py [edit]
[-] keycert.passwd.pem [edit]
[-] bisect_cmd.py [edit]
[-] talos-2019-0758.pem [edit]
[-] audiotest.au [edit]
[-] test_selectors.py [edit]
[-] test_pydoc.py [edit]
[-] test_uu.py [edit]
[-] ssltests.py [edit]
[-] test_heapq.py [edit]
[-] test_parser.py [edit]
[-] test_bufio.py [edit]
[-] test_ucn.py [edit]
[-] sample_doctest_no_doctests.py [edit]
[-] Sine-1000Hz-300ms.aif [edit]
[-] test_pkg.py [edit]
[+] support
[-] profilee.py [edit]
[-] test_codecencodings_hk.py [edit]
[-] pydocfodder.py [edit]
[-] test_graphlib.py [edit]
[-] test_raise.py [edit]
[-] test_genericalias.py [edit]
[-] curses_tests.py [edit]
[-] _typed_dict_helper.py [edit]
[-] test_doctest2.txt [edit]
[-] test_zipfile.py [edit]
[-] test_imghdr.py [edit]
[-] test_type_comments.py [edit]
[-] bad_getattr.py [edit]
[-] test_asyncore.py [edit]
[-] test_script_helper.py [edit]
[+] sndhdrdata
[-] test_ossaudiodev.py [edit]
[-] formatfloat_testcases.txt [edit]
[-] test_grammar.py [edit]
[-] test_unicodedata.py [edit]
[-] test_re.py [edit]
[-] test_pkgutil.py [edit]
[-] test_nis.py [edit]
[-] test__xxsubinterpreters.py [edit]
[-] nullbytecert.pem [edit]
[-] pydoc_mod.py [edit]
[-] test_winconsoleio.py [edit]
[-] test_abstract_numbers.py [edit]
[-] test_glob.py [edit]
[-] test_runpy.py [edit]
[+] data
[-] test__opcode.py [edit]
[+] cjkencodings
[-] test_descr.py [edit]
[-] test_codecmaps_hk.py [edit]
[-] test_future3.py [edit]
[-] test_regrtest.py [edit]
[-] test_c_locale_coercion.py [edit]
[-] test_doctest4.txt [edit]
[-] test_dis.py [edit]
[-] test_xml_etree.py [edit]
[-] ann_module5.py [edit]
[-] test_sundry.py [edit]
[-] test_pstats.py [edit]
[-] test_socketserver.py [edit]
[-] test_codeop.py [edit]
[-] test_genericpath.py [edit]
[-] test_complex.py [edit]
[-] test_grp.py [edit]
[-] test_extcall.py [edit]
[-] test_sys_setprofile.py [edit]
[-] test_threading.py [edit]
[-] test_subclassinit.py [edit]
[-] gdb_sample.py [edit]
[-] test_wsgiref.py [edit]
[-] test_fstring.py [edit]
[-] allsans.pem [edit]
[-] inspect_fodder2.py [edit]
[-] dataclass_module_2_str.py [edit]
[-] test_unary.py [edit]
[-] test_doctest.py [edit]
[-] badsyntax_future8.py [edit]
[-] test_decorators.py [edit]
[-] _test_multiprocessing.py [edit]
[-] ieee754.txt [edit]
[-] badsyntax_future4.py [edit]
[-] test_property.py [edit]
[-] test_symbol.py [edit]
[-] test_rlcompleter.py [edit]
[-] test_sort.py [edit]
[-] test_codecencodings_cn.py [edit]
[-] test_traceback.py [edit]
[-] test_xmlrpc.py [edit]
[+] test_peg_generator
[-] test_posixpath.py [edit]
[-] test_future5.py [edit]
[-] test_textwrap.py [edit]
[-] mapping_tests.py [edit]
[-] test_gzip.py [edit]
[-] floating_points.txt [edit]
[-] test_httpservers.py [edit]
[-] test_array.py [edit]
[-] test_structmembers.py [edit]
[-] test_pwd.py [edit]
[-] test_calendar.py [edit]
[-] test_dynamicclassattribute.py [edit]
[+] test_tools
[-] dataclass_module_2.py [edit]
[-] test_codecencodings_kr.py [edit]
[-] mp_fork_bomb.py [edit]
[-] ssl_key.pem [edit]
[-] test_bz2.py [edit]
[-] test_codeccallbacks.py [edit]
[-] test_deque.py [edit]
[-] test_peepholer.py [edit]
[-] test_multiprocessing_forkserver.py [edit]
[-] test_unittest.py [edit]
[-] test_asynchat.py [edit]
[-] test_struct.py [edit]
[-] test_osx_env.py [edit]
[-] test_slice.py [edit]
[-] test_finalization.py [edit]
[-] test_pipes.py [edit]
[-] test_multiprocessing_main_handling.py [edit]
[-] test_unicode_identifiers.py [edit]
[-] test_userlist.py [edit]
[-] datetimetester.py [edit]
[-] test_fork1.py [edit]
[-] test_shelve.py [edit]
[-] test_fcntl.py [edit]
[-] test_errno.py [edit]
[-] test_tempfile.py [edit]
[-] make_ssl_certs.py [edit]
[-] randv2_64.pck [edit]
[-] string_tests.py [edit]
[-] future_test1.py [edit]
[-] test_pathlib.py [edit]
[-] nullcert.pem [edit]
[-] test_wait4.py [edit]
[-] test_cmd.py [edit]
[-] test_memoryview.py [edit]
[+] audiodata
[-] test_modulefinder.py [edit]
[-] test_optparse.py [edit]
[+] libregrtest
[-] test_bigaddrspace.py [edit]
[-] test_module.py [edit]
[-] test_structseq.py [edit]
[-] test_unicode.py [edit]
[-] test_positional_only_arg.py [edit]
[-] test_wave.py [edit]
[-] test_popen.py [edit]
[-] test_multiprocessing_fork.py [edit]
[-] test_context.py [edit]
[+] test_email
[-] test_typechecks.py [edit]
[-] mp_preload.py [edit]
[-] win_console_handler.py [edit]
[-] test_capi.py [edit]
[-] multibytecodec_support.py [edit]
[-] test_lib2to3.py [edit]
[-] test_copyreg.py [edit]
[-] test_operator.py [edit]
[-] test_urllib.py [edit]
[-] test_resource.py [edit]
[-] keycert.pem [edit]
[-] test_ioctl.py [edit]
[-] test_getopt.py [edit]
[+] eintrdata
[-] badsyntax_future3.py [edit]
[-] test_buffer.py [edit]
[-] test_math.py [edit]
[-] test_thread.py [edit]
[-] keycert3.pem [edit]
[-] test_configparser.py [edit]
[-] test_float.py [edit]
[-] test_pprint.py [edit]
[-] test_long.py [edit]
[-] test_netrc.py [edit]
[-] test_concurrent_futures.py [edit]
[-] mime.types [edit]
[-] memory_watchdog.py [edit]
[-] test_compare.py [edit]
[-] test_future.py [edit]
[-] ann_module.py [edit]
[-] signalinterproctester.py [edit]
[-] badsyntax_future9.py [edit]
[-] test_baseexception.py [edit]
[-] test_timeout.py [edit]
[-] lock_tests.py [edit]
[-] test_urllib2net.py [edit]
[-] math_testcases.txt [edit]
[-] test_listcomps.py [edit]
[-] test_filecmp.py [edit]
[-] test_unpack_ex.py [edit]
[-] test_sys.py [edit]
[-] test_bytes.py [edit]
[-] selfsigned_pythontestdotnet.pem [edit]
[-] keycert2.pem [edit]
[-] test_file_eintr.py [edit]
[-] exception_hierarchy.txt [edit]
[-] test_decimal.py [edit]
[-] test_spwd.py [edit]
[-] test_aifc.py [edit]
[-] reperf.py [edit]
[-] test_userstring.py [edit]
[-] test_ordered_dict.py [edit]
[-] ann_module3.py [edit]
[-] test_threading_local.py [edit]
[-] test_pdb.py [edit]
[-] test_smtpnet.py [edit]
[-] recursion.tar [edit]
[-] test_zipimport_support.py [edit]
[+] test_warnings
[-] test_richcmp.py [edit]
[-] test_mailcap.py [edit]
[-] test_linecache.py [edit]
[-] test_weakref.py [edit]
[-] test_iter.py [edit]
[-] test_copy.py [edit]
[-] test_scope.py [edit]
[-] __main__.py [edit]
[-] test_crypt.py [edit]
[-] test_clinic.py [edit]
[-] tokenize_tests-utf8-coding-cookie-and-utf8-bom-sig.txt [edit]
[-] test_gdb.py [edit]
[-] test_audioop.py [edit]
[-] empty.vbs [edit]
[-] test_with.py [edit]
[-] inspect_fodder.py [edit]
[-] test_iterlen.py [edit]
[-] seq_tests.py [edit]
[-] test_colorsys.py [edit]
[-] test_openpty.py [edit]
[-] test_opcodes.py [edit]
[-] test_sysconfig.py [edit]
[-] test_quopri.py [edit]
[-] test_smtpd.py [edit]
[-] idnsans.pem [edit]
[-] test_site.py [edit]
[-] test_strptime.py [edit]
[-] test_code.py [edit]
[-] mock_socket.py [edit]
[-] test_genexps.py [edit]
[-] badsyntax_future10.py [edit]
[-] tokenize_tests-no-coding-cookie-and-utf8-bom-sig-only.txt [edit]
[-] test_epoll.py [edit]
[-] test_itertools.py [edit]
[-] test_cprofile.py [edit]
[-] test_uuid.py [edit]
[-] test_lltrace.py [edit]
[-] test_zipfile64.py [edit]
[-] test_tcl.py [edit]
[-] test_cgitb.py [edit]
[-] test_datetime.py [edit]
[-] test_doctest3.txt [edit]
[-] test_pulldom.py [edit]
[+] ziptestdata
[-] future_test2.py [edit]
[-] test_winreg.py [edit]
[-] test_atexit.py [edit]
[-] test_ttk_textonly.py [edit]
[-] test_bigmem.py [edit]
[-] ffdh3072.pem [edit]
[-] test_charmapcodec.py [edit]
[-] test_utf8_mode.py [edit]
[-] test_zipimport.py [edit]
[-] test_html.py [edit]
[-] test_robotparser.py [edit]
[-] test_types.py [edit]
[-] test_codecencodings_iso2022.py [edit]
[-] test_bisect.py [edit]
[-] test_class.py [edit]
[-] test_dictviews.py [edit]
[-] test_mailbox.py [edit]
[-] test_httplib.py [edit]
[-] test_bool.py [edit]
[-] test_tarfile.py [edit]
[-] test_io.py [edit]
[-] test_enum.py [edit]
[-] test_fileio.py [edit]
[-] badsyntax_3131.py [edit]
[-] test_asdl_parser.py [edit]
[-] keycertecc.pem [edit]
[-] test_code_module.py [edit]
[-] test_descrtut.py [edit]
[-] autotest.py [edit]
[-] test_poplib.py [edit]
[-] test_compileall.py [edit]
[-] test_frame.py [edit]
[-] list_tests.py [edit]
[+] test_zoneinfo
[-] coding20731.py [edit]
[-] test_imp.py [edit]
[+] test_asyncio
[-] test_pyexpat.py [edit]
[-] test_pickle.py [edit]
[-] randv3.pck [edit]
[-] bad_coding2.py [edit]
[-] test__osx_support.py [edit]
[-] test_setcomps.py [edit]
[-] fork_wait.py [edit]
[-] test_posix.py [edit]
[-] test_enumerate.py [edit]
[-] test_eof.py [edit]
[+] __pycache__
[-] tokenize_tests-utf8-coding-cookie-and-no-utf8-bom-sig.txt [edit]
[-] pythoninfo.py [edit]
[-] pickletester.py [edit]
[-] time_hashlib.py [edit]
[-] test_shlex.py [edit]
[-] test_dict_version.py [edit]
[-] test_statistics.py [edit]
[-] test_ntpath.py [edit]
[-] test_mmap.py [edit]
[-] test_difflib.py [edit]
[-] tokenize_tests-latin1-coding-cookie-and-utf8-bom-sig.txt [edit]
[-] test_curses.py [edit]
[-] test_codecencodings_jp.py [edit]
[-] test_tix.py [edit]
[-] test_timeit.py [edit]
[-] test_memoryio.py [edit]
[-] test_ftplib.py [edit]
[-] test_gettext.py [edit]
[-] clinic.test [edit]
[-] test_distutils.py [edit]
[-] test_support.py [edit]
[-] test_augassign.py [edit]
[-] test_imaplib.py [edit]
[-] test_sndhdr.py [edit]
[-] mailcap.txt [edit]
[-] test_cmath.py [edit]
[-] test_urllib_response.py [edit]
[-] ssl_key.passwd.pem [edit]
[-] test_tokenize.py [edit]
[-] test_format.py [edit]
[-] test_dynamic.py [edit]
[-] test_global.py [edit]
[-] test_os.py [edit]
[-] badcert.pem [edit]
[-] test_secrets.py [edit]
[-] test_pyclbr.py [edit]
[-] test_picklebuffer.py [edit]
[-] badkey.pem [edit]
[-] test_dbm.py [edit]
[-] test_nntplib.py [edit]
[-] test_flufl.py [edit]
[-] test_eintr.py [edit]
[-] test_multiprocessing_spawn.py [edit]
[-] test_xmlrpc_net.py [edit]
[-] tf_inherit_check.py [edit]
[-] nokia.pem [edit]
[-] test_audit.py [edit]
[-] final_b.py [edit]
[-] tokenize_tests.txt [edit]
[-] revocation.crl [edit]
[+] subprocessdata
[-] test_codecmaps_tw.py [edit]
[-] test_file.py [edit]
[-] cmath_testcases.txt [edit]
[-] test_signal.py [edit]
[-] test_codecmaps_jp.py [edit]
[-] test_int.py [edit]
[-] test_sqlite.py [edit]
[-] test_http_cookies.py [edit]
[-] sgml_input.html [edit]
[-] badsyntax_future5.py [edit]
[-] test_unicode_file_functions.py [edit]
[-] re_tests.py [edit]
[-] mod_generics_cache.py [edit]
[-] test_repl.py [edit]
[-] test_faulthandler.py [edit]
[-] test_telnetlib.py [edit]
[-] test_exceptions.py [edit]
[-] test_builtin.py [edit]
[-] test_frozen.py [edit]
[-] sortperf.py [edit]
[-] test_named_expressions.py [edit]
[-] test_codecs.py [edit]
[-] test_zipapp.py [edit]
[-] test_dictcomps.py [edit]
[-] test___future__.py [edit]
[+] dtracedata
[-] dataclass_module_1.py [edit]
[-] test_binascii.py [edit]
[-] test___all__.py [edit]
[-] testtar.tar [edit]
[+] test_json
[-] secp384r1.pem [edit]
[-] test_locale.py [edit]
[-] cfgparser.2 [edit]
[-] test_trace.py [edit]
[-] test_binop.py [edit]
[-] test_threadsignals.py [edit]
[-] test_fractions.py [edit]
[-] test_univnewlines.py [edit]
[-] test_argparse.py [edit]
[-] zipdir.zip [edit]
[-] test_marshal.py [edit]
[-] test_strtod.py [edit]
[-] test_hmac.py [edit]
[-] test_random.py [edit]
[-] test_urllib2.py [edit]
[-] test_syntax.py [edit]
[-] test_compile.py [edit]
[-] xmltests.py [edit]
[-] test_tracemalloc.py [edit]
[-] final_a.py [edit]
[-] test_functools.py [edit]
[+] capath
[-] pyclbr_input.py [edit]
[-] test_yield_from.py [edit]
[-] badsyntax_future6.py [edit]
[-] test_xml_dom_minicompat.py [edit]
[-] test_bdb.py [edit]
[-] test_ast.py [edit]
[-] test_ensurepip.py [edit]
[-] test_threadedtempfile.py [edit]
[-] test_keyword.py [edit]
[-] test_strftime.py [edit]
[-] test_logging.py [edit]
[+] decimaltestdata
[-] test_dataclasses.py [edit]
[-] test_lzma.py [edit]
[-] test_startfile.py [edit]
[-] test_venv.py [edit]
[-] test_zlib.py [edit]
[-] test_contains.py [edit]
[-] test_docxmlrpc.py [edit]
[-] test_stringprep.py [edit]
[-] test_defaultdict.py [edit]
[-] audiotests.py [edit]
[-] test_ctypes.py [edit]
[-] imp_dummy.py [edit]
[-] relimport.py [edit]
[-] test_codecencodings_tw.py [edit]
[-] test_genericclass.py [edit]
[-] cfgparser.3 [edit]
[-] dis_module.py [edit]
[-] test_cgi.py [edit]
[-] pycakey.pem [edit]
[-] test_xxtestfuzz.py [edit]
[-] test_winsound.py [edit]
[-] test_unicode_file.py [edit]
[-] test_msilib.py [edit]
[-] __init__.py [edit]
[-] pycacert.pem [edit]
[-] test_dbm_ndbm.py [edit]
[+] tracedmodules
[-] test_cmd_line.py [edit]
[-] good_getattr.py [edit]
[+] imghdrdata
[-] test_kqueue.py [edit]
[-] test_call.py [edit]
[-] bad_getattr3.py [edit]
[-] test_abc.py [edit]
[-] test_xdrlib.py [edit]
[-] test_generator_stop.py [edit]
[-] test_hash.py [edit]
[-] test_urlparse.py [edit]
[-] test_sax.py [edit]
[-] test_dict.py [edit]
[-] test_reprlib.py [edit]
[-] pstats.pck [edit]
[-] test_list.py [edit]
[-] ann_module6.py [edit]
[-] test_utf8source.py [edit]
[-] test_symtable.py [edit]
[-] test_ttk_guionly.py [edit]
[-] test_cmd_line_script.py [edit]
[-] doctest_aliases.py [edit]
[-] test_http_cookiejar.py [edit]
[-] test_turtle.py [edit]
[-] keycert4.pem [edit]
[-] ann_module2.py [edit]
[-] test_py_compile.py [edit]
[-] test_super.py [edit]
[+] test_import
[-] test_binhex.py [edit]
[-] test_coroutines.py [edit]
[-] test_contextlib_async.py [edit]
[+] encoded_modules
[-] test_ipaddress.py [edit]
[-] test_platform.py [edit]
[-] test_longexp.py [edit]
[-] test_codecmaps_cn.py [edit]
[-] test_unpack.py [edit]
[-] test_doctest.txt [edit]
[-] test_socket.py [edit]
[-] test_difflib_expect.html [edit]
[-] test_check_c_globals.py [edit]
[-] test_sys_settrace.py [edit]
[-] test_urllib2_localnet.py [edit]
[+] xmltestdata
[-] test_dtrace.py [edit]
[-] sample_doctest.py [edit]
[-] sample_doctest_no_docstrings.py [edit]
[-] test_csv.py [edit]
[-] testcodec.py [edit]
[-] badsyntax_future7.py [edit]
[-] test_htmlparser.py [edit]
[-] bad_coding.py [edit]
[-] zip_cp437_header.zip [edit]
[-] test_tabnanny.py [edit]
[-] double_const.py [edit]
[-] test_urllibnet.py [edit]
[-] test_asyncgen.py [edit]
[-] test_time.py [edit]
[-] test_pow.py [edit]
[-] test_tk.py [edit]
[-] test_profile.py [edit]
[-] test_smtplib.py [edit]
[-] test_stat.py [edit]
[-] test_generators.py [edit]
[-] test_isinstance.py [edit]
[-] test_index.py [edit]
[-] test_int_literal.py [edit]
[-] test_string.py [edit]
[-] test_keywordonlyarg.py [edit]
[-] test_fileinput.py [edit]
[-] test_weakset.py [edit]
[-] ssl_servers.py [edit]
[-] test_sched.py [edit]
[-] test_queue.py [edit]
[-] test_unparse.py [edit]
[-] test_typing.py [edit]
[-] test_poll.py [edit]
[-] test_mimetypes.py [edit]
[-] test_xml_etree_c.py [edit]
[-] test__locale.py [edit]
[-] cfgparser.1 [edit]
[-] test_select.py [edit]
[-] test_ssl.py [edit]
[-] test_print.py [edit]
[-] test_minidom.py [edit]
[-] test_contextlib.py [edit]
[-] test_exception_variations.py [edit]
[-] bad_getattr2.py [edit]
[-] test_shutil.py [edit]
[-] test_devpoll.py [edit]
[-] test_doctest2.py [edit]
[-] test_source_encoding.py [edit]
[-] audit-tests.py [edit]
[-] test_getpass.py [edit]
[-] test_fnmatch.py [edit]
[-] test_plistlib.py [edit]
[-] test_crashers.py [edit]
[-] test_future4.py [edit]
[-] test_getargs2.py [edit]
[-] test_gc.py [edit]
[-] badsyntax_pep3120.py [edit]
[-] test_userdict.py [edit]
[-] dataclass_module_1_str.py [edit]
[-] test_inspect.py [edit]
[-] test_codecmaps_kr.py [edit]
[-] test_tuple.py [edit]
[-] test_readline.py [edit]
[-] dataclass_textanno.py [edit]
[-] test_dbm_dumb.py [edit]
[+] test_importlib
[-] test_hashlib.py [edit]
[-] test_syslog.py [edit]
[-] test_pty.py [edit]
[-] test_pickletools.py [edit]
[-] regrtest.py [edit]
[-] test_wait3.py [edit]
[-] test_collections.py [edit]
[-] test_peg_parser.py [edit]
[-] test_string_literals.py [edit]
[-] test_multibytecodec.py [edit]
[-] test_range.py [edit]
[-] test_exception_hierarchy.py [edit]
[-] randv2_32.pck [edit]
[-] nosan.pem [edit]
[-] test_metaclass.py [edit]
[-] test_numeric_tower.py [edit]
[-] test_subprocess.py [edit]
[-] test_embed.py [edit]
[-] ssl_cert.pem [edit]
[-] test_dbm_gnu.py [edit]
[-] test_base64.py [edit]
[-] test_funcattrs.py [edit]