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

import collections
import contextlib
import dataclasses
import functools
import io
import itertools
import pprint
import random
import re
import types
import unittest
from collections.abc import ItemsView, KeysView, Mapping, MappingView, ValuesView

from test.support import cpython_only
from test.support.import_helper import ensure_lazy_imports

# Pin pre-3.15 width/indent for existing formatting tests.
# compact=True keeps the legacy non-JSON-style container wrapping.
_pformat = functools.partial(pprint.pformat, indent=1, width=80, compact=True)

# 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 list_custom_repr(list):
    def __repr__(self):
        return '*'*len(list.__repr__(self))

class tuple2(tuple):
    pass

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

class tuple_custom_repr(tuple):
    def __repr__(self):
        return '*'*len(tuple.__repr__(self))

class set2(set):
    pass

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

class set_custom_repr(set):
    def __repr__(self):
        return '*'*len(set.__repr__(self))

class frozenset2(frozenset):
    pass

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

class frozenset_custom_repr(frozenset):
    def __repr__(self):
        return '*'*len(frozenset.__repr__(self))

class dict2(dict):
    pass

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

class frozendict2(frozendict):
    pass

class frozendict3(frozendict):
    def __repr__(self):
        return frozendict.__repr__(self)

class dict_custom_repr(dict):
    def __repr__(self):
        return '*'*len(dict.__repr__(self))

class mappingview_custom_repr(MappingView):
    def __repr__(self):
        return '*'*len(MappingView.__repr__(self))

class keysview_custom_repr(KeysView):
    def __repr__(self):
        return '*'*len(KeysView.__repr__(self))

@dataclasses.dataclass
class dataclass1:
    field1: str
    field2: int
    field3: bool = False
    field4: int = dataclasses.field(default=1, repr=False)

@dataclasses.dataclass
class dataclass2:
    a: int = 1
    def __repr__(self):
        return "custom repr that doesn't fit within pprint width"

@dataclasses.dataclass(repr=False)
class dataclass3:
    a: int = 1

@dataclasses.dataclass
class dataclass4:
    a: "dataclass4"
    b: int = 1

@dataclasses.dataclass
class dataclass5:
    a: "dataclass6"
    b: int = 1

@dataclasses.dataclass
class dataclass6:
    c: "dataclass5"
    d: int = 1

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

    @cpython_only
    def test_lazy_import(self):
        ensure_lazy_imports("pprint", {"dataclasses", "re"})

    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_stdout_is_None(self):
        with contextlib.redirect_stdout(None):
            # smoke test - there is no output to check
            value = 'this should not fail'
            pprint.pprint(value)
            pprint.PrettyPrinter().pprint(value)

    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
        self.e = {}
        self.v = ValuesView(self.e)
        self.m = MappingView(self.e)
        self.dv = self.e.values()
        self.e["v"] = self.v
        self.e["m"] = self.m
        self.e["dv"] = self.dv

        pp = pprint.PrettyPrinter()

        for icky in self.a, self.b, self.d, (self.d, self.d), self.e, self.v, self.m, self.dv:
            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()
        self.e.clear()
        del self.a[:]
        del self.b[:]

        for safe in self.a, self.b, self.d, (self.d, self.d), self.e, self.v, self.m, self.dv:
            # 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 object(), int, 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 override __repr__
        # to directly call super's __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(),
                       frozendict(), frozendict2(), frozendict3(),
                       {}.keys(), {}.values(), {}.items(),
                       MappingView({}), KeysView({}), ItemsView({}), ValuesView({}),
                       self.assertTrue, pprint,
                       -6, -6, -6-6j, -1.5, "x", b"x", bytearray(b"x"),
                       (3,), [3], {3: 6},
                       (1,2), [3,4],
                       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}),
                       {5: 6}, dict2({5: 6}), dict3({5: 6}),
                       frozendict({5: 6}), frozendict2({5: 6}), frozendict3({5: 6}),
                       {5: 6}.keys(), {5: 6}.values(), {5: 6}.items(),
                       frozendict({5: 6}).keys(), frozendict({5: 6}).values(),
                       frozendict({5: 6}).items(),
                       MappingView({5: 6}), KeysView({5: 6}),
                       ItemsView({5: 6}), ValuesView({5: 6}),
                       range(10, -11, -1),
                       True, False, None, ...,
                      ):
            native = repr(simple)
            self.assertEqual(_pformat(simple), native)
            self.assertEqual(_pformat(simple, width=1, indent=0)
                             .replace('\n', ' '), native)
            self.assertEqual(_pformat(simple, underscore_numbers=True), native)
            self.assertEqual(pprint.saferepr(simple), native)

    def test_container_repr_override_called(self):
        N = 1000
        # Ensure that __repr__ override is called for subclasses of containers

        for cont in (list_custom_repr(),
                     list_custom_repr([1,2,3]),
                     list_custom_repr(range(N)),
                     tuple_custom_repr(),
                     tuple_custom_repr([1,2,3]),
                     tuple_custom_repr(range(N)),
                     set_custom_repr(),
                     set_custom_repr([1,2,3]),
                     set_custom_repr(range(N)),
                     frozenset_custom_repr(),
                     frozenset_custom_repr([1,2,3]),
                     frozenset_custom_repr(range(N)),
                     dict_custom_repr(),
                     dict_custom_repr({5: 6}),
                     dict_custom_repr(zip(range(N),range(N))),
                     mappingview_custom_repr({}),
                     mappingview_custom_repr({5: 6}),
                     mappingview_custom_repr(dict(zip(range(N),range(N)))),
                     keysview_custom_repr({}),
                     keysview_custom_repr({5: 6}),
                     keysview_custom_repr(dict(zip(range(N),range(N)))),
                    ):
            native = repr(cont)
            expected = '*' * len(native)
            self.assertEqual(_pformat(cont), expected)
            self.assertEqual(_pformat(cont, width=1, indent=0), expected)
            self.assertEqual(pprint.saferepr(cont), expected)

    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(_pformat(type(o)), exp)

        exp = """\
frozendict({'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})"""
        self.assertEqual(_pformat(frozendict(o)), exp)
        exp = """\
frozendict2({'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})"""
        self.assertEqual(_pformat(frozendict2(o)), exp)

        o = range(100)
        exp = 'dict_keys([%s])' % ',\n '.join(map(str, o))
        keys = dict.fromkeys(o).keys()
        self.assertEqual(_pformat(keys, width=1), exp)
        keys = frozendict.fromkeys(o).keys()
        self.assertEqual(_pformat(keys, width=1), exp)

        o = range(100)
        exp = 'dict_values([%s])' % ',\n '.join(map(str, o))
        values = {v: v for v in o}.values()
        self.assertEqual(_pformat(values, width=1), exp)
        values = frozendict({v: v for v in o}).values()
        self.assertEqual(_pformat(values, width=1), exp)

        o = range(100)
        exp = 'dict_items([%s])' % ',\n '.join("(%s, %s)" % (i, i) for i in o)
        items = {v: v for v in o}.items()
        self.assertEqual(_pformat(items, width=11), exp)
        items = frozendict({v: v for v in o}).items()
        self.assertEqual(_pformat(items, width=11), exp)

        o = range(100)
        exp = 'odict_keys([%s])' % ',\n '.join(map(str, o))
        keys = collections.OrderedDict.fromkeys(o).keys()
        self.assertEqual(_pformat(keys, width=1), exp)

        o = range(100)
        exp = 'odict_values([%s])' % ',\n '.join(map(str, o))
        values = collections.OrderedDict({v: v for v in o}).values()
        self.assertEqual(_pformat(values, width=1), exp)

        o = range(100)
        exp = 'odict_items([%s])' % ',\n '.join("(%s, %s)" % (i, i) for i in o)
        items = collections.OrderedDict({v: v for v in o}).items()
        self.assertEqual(_pformat(items, width=11), exp)

        o = range(100)
        exp = 'KeysView({%s})' % (': None,\n '.join(map(str, o)) + ': None')
        keys_view = KeysView(dict.fromkeys(o))
        self.assertEqual(_pformat(keys_view), exp)

        o = range(100)
        exp = 'ItemsView({%s})' % (': None,\n '.join(map(str, o)) + ': None')
        items_view = ItemsView(dict.fromkeys(o))
        self.assertEqual(_pformat(items_view), exp)

        o = range(100)
        exp = 'MappingView({%s})' % (': None,\n '.join(map(str, o)) + ': None')
        mapping_view = MappingView(dict.fromkeys(o))
        self.assertEqual(_pformat(mapping_view), exp)

        o = range(100)
        exp = 'ValuesView({%s})' % (': None,\n '.join(map(str, o)) + ': None')
        values_view = ValuesView(dict.fromkeys(o))
        self.assertEqual(_pformat(values_view), exp)

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

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

        # indent parameter
        o = range(100)
        exp = '[   %s]' % ',\n    '.join(map(str, o))
        for type in [list, list2]:
            self.assertEqual(_pformat(type(o), indent=4, width=1), 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, compact=True), 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, compact=True), 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(_pformat(o, width=15), expected)
        self.assertEqual(_pformat(o, width=16), expected)
        self.assertEqual(_pformat(o, width=25), expected)
        self.assertEqual(_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_integer(self):
        self.assertEqual(_pformat(1234567), '1234567')
        self.assertEqual(_pformat(1234567, underscore_numbers=True), '1_234_567')

        class Temperature(int):
            def __new__(cls, celsius_degrees):
                return super().__new__(Temperature, celsius_degrees)
            def __repr__(self):
                kelvin_degrees = self + 273.15
                return f"{kelvin_degrees:.2f}°K"
        self.assertEqual(_pformat(Temperature(1000)), '1273.15°K')

    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(_pformat(d), "{'a': 1, 'b': 1, 'c': 1}")
        self.assertEqual(_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(_pformat({"xy\tab\n": (3,), 5: [[]], (): {}}),
            r"{5: [[]], 'xy\tab\n': (3,), (): {}}")

    def test_sort_dict(self):
        d = dict.fromkeys('cba')
        self.assertEqual(_pformat(d, sort_dicts=False), "{'c': None, 'b': None, 'a': None}")
        self.assertEqual(_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(_pformat(d, width=1), 'OrderedDict()')
        d = collections.OrderedDict([])
        self.assertEqual(_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(_pformat(d),
"""\
OrderedDict([('the', 0), ('quick', 1), ('brown', 2), ('fox', 3), ('jumped', 4),
             ('over', 5), ('a', 6), ('lazy', 7), ('dog', 8)])""")
        self.assertEqual(
            _pformat(d.keys(), sort_dicts=False),
            "odict_keys(['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'a', 'lazy', 'dog'])",
        )
        self.assertEqual(_pformat(d.items(), sort_dicts=False),
"""\
odict_items([('the', 0), ('quick', 1), ('brown', 2), ('fox', 3), ('jumped', 4), ('over', 5),
 ('a', 6), ('lazy', 7), ('dog', 8)])""")
        self.assertEqual(_pformat(d.values(), sort_dicts=False),
                         "odict_values([0, 1, 2, 3, 4, 5, 6, 7, 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(_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(_pformat(m), """\
mappingproxy(OrderedDict([('the', 0), ('quick', 1), ('brown', 2), ('fox', 3),
                          ('jumped', 4), ('over', 5), ('a', 6), ('lazy', 7),
                          ('dog', 8)]))""")

    def test_dict_views(self):
        for dict_class in (dict, collections.OrderedDict, collections.Counter):
            empty = dict_class({})
            short = dict_class(dict(zip('edcba', 'edcba')))
            lengths = {"empty": empty, "short": short}
            prefix = "odict" if dict_class is collections.OrderedDict else "dict"
            for name, d in lengths.items():
                with self.subTest(length=name, prefix=prefix):
                    k = d.keys()
                    v = d.values()
                    i = d.items()
                    self.assertEqual(_pformat(k, sort_dicts=True),
                                     prefix + "_keys([%s])" %
                                     ", ".join(repr(key) for key in sorted(k)))
                    self.assertEqual(_pformat(v, sort_dicts=True),
                                     prefix + "_values([%s])" %
                                     ", ".join(repr(val) for val in sorted(v)))
                    self.assertEqual(_pformat(i, sort_dicts=True),
                                     prefix + "_items([%s])" %
                                     ", ".join(repr(item) for item in sorted(i)))
                    self.assertEqual(_pformat(k, sort_dicts=False),
                                     prefix + "_keys([%s])" %
                                     ", ".join(repr(key) for key in k))
                    self.assertEqual(_pformat(v, sort_dicts=False),
                                     prefix + "_values([%s])" %
                                     ", ".join(repr(val) for val in v))
                    self.assertEqual(_pformat(i, sort_dicts=False),
                                     prefix + "_items([%s])" %
                                     ", ".join(repr(item) for item in i))

        # Long case: views wrap with compact-mode packing.
        long = dict((chr(x), chr(x)) for x in range(90, 64, -1))
        sorted_keys = (
            "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',\n"
            " 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']"
        )
        unsorted_keys = (
            "['Z', 'Y', 'X', 'W', 'V', 'U', 'T', 'S', 'R', 'Q', 'P', 'O', 'N', 'M', 'L', 'K',\n"
            " 'J', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'B', 'A']"
        )
        sorted_items = (
            "[('A', 'A'), ('B', 'B'), ('C', 'C'), ('D', 'D'), ('E', 'E'), ('F', 'F'),\n"
            " ('G', 'G'), ('H', 'H'), ('I', 'I'), ('J', 'J'), ('K', 'K'), ('L', 'L'),\n"
            " ('M', 'M'), ('N', 'N'), ('O', 'O'), ('P', 'P'), ('Q', 'Q'), ('R', 'R'),\n"
            " ('S', 'S'), ('T', 'T'), ('U', 'U'), ('V', 'V'), ('W', 'W'), ('X', 'X'),\n"
            " ('Y', 'Y'), ('Z', 'Z')]"
        )
        unsorted_items = (
            "[('Z', 'Z'), ('Y', 'Y'), ('X', 'X'), ('W', 'W'), ('V', 'V'), ('U', 'U'),\n"
            " ('T', 'T'), ('S', 'S'), ('R', 'R'), ('Q', 'Q'), ('P', 'P'), ('O', 'O'),\n"
            " ('N', 'N'), ('M', 'M'), ('L', 'L'), ('K', 'K'), ('J', 'J'), ('I', 'I'),\n"
            " ('H', 'H'), ('G', 'G'), ('F', 'F'), ('E', 'E'), ('D', 'D'), ('C', 'C'),\n"
            " ('B', 'B'), ('A', 'A')]"
        )
        for dict_class in (dict, collections.OrderedDict, collections.Counter):
            d = dict_class(long)
            prefix = "odict" if dict_class is collections.OrderedDict else "dict"
            with self.subTest(length="long", prefix=prefix):
                self.assertEqual(_pformat(d.keys(), sort_dicts=True),
                                 f"{prefix}_keys({sorted_keys})")
                self.assertEqual(_pformat(d.values(), sort_dicts=True),
                                 f"{prefix}_values({sorted_keys})")
                self.assertEqual(_pformat(d.items(), sort_dicts=True),
                                 f"{prefix}_items({sorted_items})")
                self.assertEqual(_pformat(d.keys(), sort_dicts=False),
                                 f"{prefix}_keys({unsorted_keys})")
                self.assertEqual(_pformat(d.values(), sort_dicts=False),
                                 f"{prefix}_values({unsorted_keys})")
                self.assertEqual(_pformat(d.items(), sort_dicts=False),
                                 f"{prefix}_items({unsorted_items})")

    def test_abc_views(self):
        empty = {}
        short = dict(zip('edcba', 'edcba'))
        long = dict((chr(x), chr(x)) for x in range(90, 64, -1))
        lengths = {"empty": empty, "short": short, "long": long}
        # Test that a subclass that doesn't replace __repr__ works with different lengths
        class MV(MappingView): pass

        for name, d in lengths.items():
            with self.subTest(length=name, name="Views"):
                is_short = len(d) < 6
                joiner = ", " if is_short else ",\n "
                i = d.items()
                s = sorted(i)
                joined_items = "({%s})" % joiner.join(["%r: %r" % (k, v) for (k, v) in i])
                sorted_items = "({%s})" % joiner.join(["%r: %r" % (k, v) for (k, v) in s])
                self.assertEqual(_pformat(KeysView(d), sort_dicts=True),
                                 KeysView.__name__ + sorted_items)
                self.assertEqual(_pformat(ItemsView(d), sort_dicts=True),
                                 ItemsView.__name__ + sorted_items)
                self.assertEqual(_pformat(MappingView(d), sort_dicts=True),
                                 MappingView.__name__ + sorted_items)
                self.assertEqual(_pformat(MV(d), sort_dicts=True),
                                 MV.__name__ + sorted_items)
                self.assertEqual(_pformat(ValuesView(d), sort_dicts=True),
                                 ValuesView.__name__ + sorted_items)
                self.assertEqual(_pformat(KeysView(d), sort_dicts=False),
                                 KeysView.__name__ + joined_items)
                self.assertEqual(_pformat(ItemsView(d), sort_dicts=False),
                                 ItemsView.__name__ + joined_items)
                self.assertEqual(_pformat(MappingView(d), sort_dicts=False),
                                 MappingView.__name__ + joined_items)
                self.assertEqual(_pformat(MV(d), sort_dicts=False),
                                 MV.__name__ + joined_items)
                self.assertEqual(_pformat(ValuesView(d), sort_dicts=False),
                                 ValuesView.__name__ + joined_items)

    def test_nested_views(self):
        d = {1: MappingView({1: MappingView({1: MappingView({1: 2})})})}
        self.assertEqual(repr(d),
                         "{1: MappingView({1: MappingView({1: MappingView({1: 2})})})}")
        self.assertEqual(_pformat(d),
                         "{1: MappingView({1: MappingView({1: MappingView({1: 2})})})}")
        self.assertEqual(_pformat(d, depth=2),
                         "{1: MappingView({1: {...}})}")
        d = {}
        d1 = {1: d.values()}
        d2 = {1: d1.values()}
        d3 = {1: d2.values()}
        self.assertEqual(_pformat(d3),
                         "{1: dict_values([dict_values([dict_values([])])])}")
        self.assertEqual(_pformat(d3, depth=2),
                         "{1: dict_values([{...}])}")

    def test_unorderable_items_views(self):
        """Check that views with unorderable items have stable sorting."""
        d = dict((((3+1j), 3), ((1+1j), (1+0j)), (1j, 0j), (500, None), (499, None)))
        iv = ItemsView(d)
        self.assertEqual(_pformat(iv),
                         _pformat(iv))
        self.assertTrue(_pformat(iv).endswith(", 499: None, 500: None})"),
                        _pformat(iv))
        self.assertEqual(_pformat(d.items()),  # Won't be equal unless _safe_tuple
                         _pformat(d.items()))  # is used in _safe_repr
        self.assertTrue(_pformat(d.items()).endswith(", (499, None), (500, None)])"))

    def test_mapping_view_subclass_no_mapping(self):
        class BMV(MappingView):
            def __init__(self, d):
                super().__init__(d)
                self.mapping = self._mapping
                del self._mapping

        self.assertRaises(AttributeError, _pformat, BMV({}))

    def test_mapping_subclass_repr(self):
        """Test that mapping ABC views use their ._mapping's __repr__."""
        class MyMapping(Mapping):
            def __init__(self, keys=None):
                self._keys = {} if keys is None else dict.fromkeys(keys)

            def __getitem__(self, item):
                return self._keys[item]

            def __len__(self):
                return len(self._keys)

            def __iter__(self):
                return iter(self._keys)

            def __repr__(self):
                return f"{self.__class__.__name__}([{', '.join(map(repr, self._keys.keys()))}])"

        m = MyMapping(["test", 1])
        self.assertEqual(repr(m), "MyMapping(['test', 1])")
        short_view_repr = "%s(MyMapping(['test', 1]))"
        self.assertEqual(repr(m.keys()), short_view_repr % "KeysView")
        self.assertEqual(_pformat(m.items()), short_view_repr % "ItemsView")
        self.assertEqual(_pformat(m.keys()), short_view_repr % "KeysView")
        self.assertEqual(_pformat(MappingView(m)), short_view_repr % "MappingView")
        self.assertEqual(_pformat(m.values()), short_view_repr % "ValuesView")

        alpha = "abcdefghijklmnopqrstuvwxyz"
        m = MyMapping(alpha)
        alpha_repr = ", ".join(map(repr, list(alpha)))
        long_view_repr = "%%s(MyMapping([%s]))" % alpha_repr
        self.assertEqual(repr(m), "MyMapping([%s])" % alpha_repr)
        self.assertEqual(repr(m.keys()), long_view_repr % "KeysView")
        self.assertEqual(_pformat(m.items()), long_view_repr % "ItemsView")
        self.assertEqual(_pformat(m.keys()), long_view_repr % "KeysView")
        self.assertEqual(_pformat(MappingView(m)), long_view_repr % "MappingView")
        self.assertEqual(_pformat(m.values()), long_view_repr % "ValuesView")

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

    def test_small_simple_namespace(self):
        ns = types.SimpleNamespace(a=1, b=2)
        formatted = _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, indent=4, compact=True)
        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 = _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_empty_dataclass(self):
        dc = dataclasses.make_dataclass("MyDataclass", ())()
        formatted = _pformat(dc)
        self.assertEqual(formatted, "MyDataclass()")

    def test_small_dataclass(self):
        dc = dataclass1("text", 123)
        formatted = _pformat(dc)
        self.assertEqual(formatted, "dataclass1(field1='text', field2=123, field3=False)")

    def test_larger_dataclass(self):
        dc = dataclass1("some fairly long text", int(1e10), True)
        formatted = pprint.pformat([dc, dc], width=60, indent=4, compact=True)
        self.assertEqual(formatted, """\
[   dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True),
    dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True)]""")

    def test_dataclass_with_repr(self):
        dc = dataclass2()
        formatted = _pformat(dc, width=20)
        self.assertEqual(formatted, "custom repr that doesn't fit within pprint width")

    def test_dataclass_no_repr(self):
        dc = dataclass3()
        formatted = _pformat(dc, width=10)
        self.assertRegex(
            formatted,
            fr"<{re.escape(__name__)}.dataclass3 object at \w+>",
        )

    def test_recursive_dataclass(self):
        dc = dataclass4(None)
        dc.a = dc
        formatted = _pformat(dc, width=10)
        self.assertEqual(formatted, """\
dataclass4(a=...,
           b=1)""")

    def test_cyclic_dataclass(self):
        dc5 = dataclass5(None)
        dc6 = dataclass6(None)
        dc5.a = dc6
        dc6.c = dc5
        formatted = _pformat(dc5, width=10)
        self.assertEqual(formatted, """\
dataclass5(a=dataclass6(c=...,
                        d=1),
           b=1)""")

    def test_subclassing(self):
        # length(repr(obj)) > width
        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}"""

        dotted_printer = DottedPrettyPrinter(indent=1, compact=True)
        self.assertEqual(dotted_printer.pformat(o), exp)

        # length(repr(obj)) < width
        o1 = ['with space']
        exp1 = "['with space']"
        self.assertEqual(dotted_printer.pformat(o1), exp1)
        o2 = ['without.space']
        exp2 = "[without.space]"
        self.assertEqual(dotted_printer.pformat(o2), exp2)

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

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

    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."
        #
        # >>> frozenset({0}) < frozenset({1})
        # False
        # >>> frozenset({1}) < frozenset({0})
        # False
        #
        # In this test we list all possible invariants of the result
        # for unordered frozensets.
        #
        # This test has a long history, see:
        # - https://github.com/python/cpython/commit/969fe57baa0eb80332990f9cda936a33e13fabef
        # - https://github.com/python/cpython/issues/58115
        # - https://github.com/python/cpython/issues/111147

        import textwrap

        # Single-line, always ordered:
        fs0 = frozenset()
        fs1 = frozenset(('abc', 'xyz'))
        data = frozenset((fs0, fs1))
        self.assertEqual(_pformat(data),
                         'frozenset({%r, %r})' % (fs0, fs1))
        self.assertEqual(_pformat(data), repr(data))

        fs2 = frozenset(('one', 'two'))
        data = {fs2: frozenset((fs0, fs1))}
        self.assertEqual(_pformat(data),
                         "{%r: frozenset({%r, %r})}" % (fs2, fs0, fs1))
        self.assertEqual(_pformat(data), repr(data))

        # Single-line, unordered:
        fs1 = frozenset(("xyz", "qwerty"))
        fs2 = frozenset(("abcd", "spam"))
        fs = frozenset((fs1, fs2))
        self.assertEqual(_pformat(fs), repr(fs))

        # Multiline, unordered:
        def check(res, invariants):
            self.assertIn(res, [textwrap.dedent(i).strip() for i in invariants])

        # Inner-most frozensets are singleline, result is multiline, unordered:
        fs1 = frozenset(('regular string', 'other string'))
        fs2 = frozenset(('third string', 'one more string'))
        check(
            _pformat(frozenset((fs1, fs2))),
            [
                """
                frozenset({%r,
                           %r})
                """ % (fs1, fs2),
                """
                frozenset({%r,
                           %r})
                """ % (fs2, fs1),
            ],
        )

        # Everything is multiline, unordered:
        check(
            _pformat(
                frozenset((
                    frozenset((
                        "xyz very-very long string",
                        "qwerty is also absurdly long",
                    )),
                    frozenset((
                        "abcd is even longer that before",
                        "spam is not so long",
                    )),
                )),
            ),
            [
                """
                frozenset({frozenset({'abcd is even longer that before',
                                      'spam is not so long'}),
                           frozenset({'qwerty is also absurdly long',
                                      'xyz very-very long string'})})
                """,

                """
                frozenset({frozenset({'abcd is even longer that before',
                                      'spam is not so long'}),
                           frozenset({'xyz very-very long string',
                                      'qwerty is also absurdly long'})})
                """,

                """
                frozenset({frozenset({'qwerty is also absurdly long',
                                      'xyz very-very long string'}),
                           frozenset({'abcd is even longer that before',
                                      'spam is not so long'})})
                """,

                """
                frozenset({frozenset({'qwerty is also absurdly long',
                                      'xyz very-very long string'}),
                           frozenset({'spam is not so long',
                                      'abcd is even longer that before'})})
                """,
            ],
        )

    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(_pformat(nested_tuple), repr(nested_tuple))
        self.assertEqual(_pformat(nested_dict), repr(nested_dict))
        self.assertEqual(_pformat(nested_list), repr(nested_list))

        lv1_tuple = '(1, (...))'
        lv1_dict = '{1: {...}}'
        lv1_list = '[1, [...]]'
        self.assertEqual(_pformat(nested_tuple, depth=1), lv1_tuple)
        self.assertEqual(_pformat(nested_dict, depth=1), lv1_dict)
        self.assertEqual(_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(_pformat(set(keys))),
            '{' + ','.join(map(repr, skeys)) + '}')
        self.assertEqual(clean(_pformat(frozenset(keys))),
            'frozenset({' + ','.join(map(repr, skeys)) + '})')
        self.assertEqual(clean(_pformat(dict.fromkeys(keys))),
            '{' + ','.join('%r:None' % k for k in skeys) + '}')
        self.assertEqual(clean(_pformat(dict.fromkeys(keys).keys())),
            'dict_keys([' + ','.join('%r' % k for k in skeys) + '])')
        self.assertEqual(clean(_pformat(dict.fromkeys(keys).items())),
            'dict_items([' + ','.join('(%r,None)' % k for k in skeys) + '])')

        # Issue 10017: TypeError on user-defined types as dict keys.
        self.assertEqual(_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(_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(_pformat(set([b, a]), width=1),
                         '{%r,\n %r}' % (a, b))
        self.assertEqual(_pformat(set([a, b]), width=1),
                         '{%r,\n %r}' % (a, b))
        # dict
        self.assertEqual(_pformat(dict.fromkeys([b, a]), width=1),
                         '{%r: None,\n %r: None}' % (a, b))
        self.assertEqual(_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(_pformat(fox, width=19), """\
('the quick brown '
 'fox jumped over '
 'a lazy dog')""")
        self.assertEqual(_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(_pformat(special, width=68), repr(special))
        self.assertEqual(_pformat(special, width=31), """\
('Portons dix bons "whiskys"\\n'
 "à l'avocat goujat\\t qui "
 'fumait au zoo')""")
        self.assertEqual(_pformat(special, width=20), """\
('Portons dix bons '
 '"whiskys"\\n'
 "à l'avocat "
 'goujat\\t qui '
 'fumait au zoo')""")
        self.assertEqual(_pformat([[[[[special]]]]], width=35), """\
[[[[['Portons dix bons "whiskys"\\n'
     "à l'avocat goujat\\t qui "
     'fumait au zoo']]]]]""")
        self.assertEqual(_pformat([[[[[special]]]]], width=25), """\
[[[[['Portons dix bons '
     '"whiskys"\\n'
     "à l'avocat "
     'goujat\\t qui '
     'fumait au zoo']]]]]""")
        self.assertEqual(_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(_pformat(unwrappable, width=80), repr(unwrappable))
        self.assertEqual(_pformat(''), "''")
        # Check that the pprint is a usable repr
        special *= 10
        for width in range(3, 40):
            formatted = _pformat(special, width=width)
            self.assertEqual(eval(formatted), special)
            formatted = _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(_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 = _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(_pformat(b'', width=1), "b''")
        self.assertEqual(_pformat(b'abcd', width=1), "b'abcd'")
        letters = b'abcdefghijklmnopqrstuvwxyz'
        self.assertEqual(_pformat(letters, width=29), repr(letters))
        self.assertEqual(_pformat(letters, width=19), """\
(b'abcdefghijkl'
 b'mnopqrstuvwxyz')""")
        self.assertEqual(_pformat(letters, width=18), """\
(b'abcdefghijkl'
 b'mnopqrstuvwx'
 b'yz')""")
        self.assertEqual(_pformat(letters, width=16), """\
(b'abcdefghijkl'
 b'mnopqrstuvwx'
 b'yz')""")
        special = bytes(range(16))
        self.assertEqual(_pformat(special, width=61), repr(special))
        self.assertEqual(_pformat(special, width=48), """\
(b'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b'
 b'\\x0c\\r\\x0e\\x0f')""")
        self.assertEqual(_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(_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(_pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=21), """\
{'a': 1,
 'b': b'abcdefghijkl'
      b'mnopqrstuvwx'
      b'yz',
 'c': 2}""")
        self.assertEqual(_pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=20), """\
{'a': 1,
 'b': b'abcdefgh'
      b'ijklmnop'
      b'qrstuvwxyz',
 'c': 2}""")
        self.assertEqual(_pformat([[[[[[letters]]]]]], width=25), """\
[[[[[[b'abcdefghijklmnop'
      b'qrstuvwxyz']]]]]]""")
        self.assertEqual(_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 = _pformat(special, width=width)
            self.assertEqual(eval(formatted), special)
            formatted = _pformat([special] * 2, width=width)
            self.assertEqual(eval(formatted), [special] * 2)

    def test_bytearray_wrap(self):
        self.assertEqual(_pformat(bytearray(), width=1), "bytearray(b'')")
        letters = bytearray(b'abcdefghijklmnopqrstuvwxyz')
        self.assertEqual(_pformat(letters, width=40), repr(letters))
        self.assertEqual(_pformat(letters, width=28), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwxyz')""")
        self.assertEqual(_pformat(letters, width=27), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwx'
          b'yz')""")
        self.assertEqual(_pformat(letters, width=25), """\
bytearray(b'abcdefghijkl'
          b'mnopqrstuvwx'
          b'yz')""")
        special = bytearray(range(16))
        self.assertEqual(_pformat(special, width=72), repr(special))
        self.assertEqual(_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(_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(_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(_pformat({'a': 1, 'b': letters, 'c': 2},
                                        width=31), """\
{'a': 1,
 'b': bytearray(b'abcdefghijkl'
                b'mnopqrstuvwx'
                b'yz'),
 'c': 2}""")
        self.assertEqual(_pformat([[[[[letters]]]]], width=37), """\
[[[[[bytearray(b'abcdefghijklmnop'
               b'qrstuvwxyz')]]]]]""")
        self.assertEqual(_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(_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(_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(_pformat(d, width=1), "Counter()")
        d = collections.Counter('senselessness')
        self.assertEqual(_pformat(d, width=40),
"""\
Counter({'s': 6,
         'e': 4,
         'n': 2,
         'l': 1})""")
        self.assertEqual(_pformat(d, indent=2, width=1),
"""\
Counter({ 's': 6,
          'e': 4,
          'n': 2,
          'l': 1})""")

    def test_chainmap(self):
        d = collections.ChainMap()
        self.assertEqual(_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(_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(_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)]))""")
        self.assertEqual(_pformat(d.keys()),
"""\
KeysView(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)])))""")
        self.assertEqual(_pformat(d.items()),
 """\
ItemsView(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)])))""")
        self.assertEqual(_pformat(d.values()),
 """\
ValuesView(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(_pformat(d, width=1), "deque([])")
        d = collections.deque(maxlen=7)
        self.assertEqual(_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(_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(_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(_pformat(d, width=1), "{}")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.UserDict(zip(words, itertools.count()))
        self.assertEqual(_pformat(d),
"""\
{'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0}""")
        self.assertEqual(_pformat(d.keys()), """\
KeysView({'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0})""")
        self.assertEqual(_pformat(d.items()), """\
ItemsView({'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0})""")
        self.assertEqual(_pformat(d.values()), """\
ValuesView({'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(_pformat(d, width=1), "[]")
        words = 'the quick brown fox jumped over a lazy dog'.split()
        d = collections.UserList(zip(words, itertools.count()))
        self.assertEqual(_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(_pformat(d, width=1), "''")
        d = collections.UserString('the quick brown fox jumped over a lazy dog')
        self.assertEqual(_pformat(d, width=20),
"""\
('the quick brown '
 'fox jumped over '
 'a lazy dog')""")
        self.assertEqual(_pformat({1: d}, width=20),
"""\
{1: 'the quick '
    'brown fox '
    'jumped over a '
    'lazy dog'}""")

    def test_template(self):
        d = t""
        self.assertEqual(_pformat(d),
                         "Template(strings=('',), interpolations=())")
        self.assertEqual(_pformat(d), repr(d))
        self.assertEqual(_pformat(d, width=1),
"""\
Template(strings=('',),
         interpolations=())""")
        name = "World"
        d = t"Hello {name}"
        self.assertEqual(_pformat(d),
"""\
Template(strings=('Hello ', ''),
         interpolations=(Interpolation('World', 'name', None, ''),))""")
        ver = {3.13: False, 3.14: True}
        d = t"Hello { {"name": "Python", "version": ver}!s:z}!"
        self.assertEqual(_pformat(d, width=1),
"""\
Template(strings=('Hello ',
                  '!'),
         interpolations=(Interpolation({'name': 'Python',
                                        'version': {3.13: False,
                                                    3.14: True}},
                                       ' '
                                       '{"name": '
                                       '"Python", '
                                       '"version": '
                                       'ver}',
                                       's',
                                       'z'),))""")

    def test_expand_template(self):
        d = t""
        self.assertEqual(
            pprint.pformat(d),
            "Template(strings=('',), interpolations=())",
        )
        name = "World"
        d = t"Hello {name}"
        self.assertEqual(
            pprint.pformat(d, width=40, indent=4),
            """\
Template(
    strings=('Hello ', ''),
    interpolations=(
        Interpolation(
            value='World',
            expression='name',
            conversion=None,
            format_spec='',
        ),
    ),
)""",
        )
        ver = {3.13: False, 3.14: True}
        d = t"Hello { {"name": "Python", "version": ver}!s:z}!"
        self.assertEqual(
            pprint.pformat(d, width=40, indent=4),
            """\
Template(
    strings=('Hello ', '!'),
    interpolations=(
        Interpolation(
            value={
                'name': 'Python',
                'version': {
                    3.13: False,
                    3.14: True,
                },
            },
            expression=' {"name": "Python", '
            '"version": ver}',
            conversion='s',
            format_spec='z',
        ),
    ),
)""",
        )

    def test_expand_dataclass(self):
        @dataclasses.dataclass
        class DummyDataclass:
            foo: str
            bar: float
            baz: bool
            qux: dict = dataclasses.field(default_factory=dict)
            quux: list = dataclasses.field(default_factory=list)
            corge: int = 1
            garply: tuple = (1, 2, 3, 4)
        dummy_dataclass = DummyDataclass(
            foo="foo",
            bar=1.2,
            baz=False,
            qux={"foo": "bar", "baz": 123},
            quux=["foo", "bar", "baz"],
            corge=7,
            garply=(1, 2, 3, 4),
        )
        self.assertEqual(pprint.pformat(dummy_dataclass, width=40, indent=4),
"""\
DummyDataclass(
    foo='foo',
    bar=1.2,
    baz=False,
    qux={'baz': 123, 'foo': 'bar'},
    quux=['foo', 'bar', 'baz'],
    corge=7,
    garply=(1, 2, 3, 4),
)""")

    def test_expand_dict(self):
        dummy_dict = {
            "foo": "bar",
            "baz": 123,
            "qux": {"foo": "bar", "baz": 123},
            "quux": ["foo", "bar", "baz"],
            "corge": 7,
        }
        self.assertEqual(pprint.pformat(dummy_dict, width=40, indent=4, sort_dicts=False),
"""\
{
    'foo': 'bar',
    'baz': 123,
    'qux': {'foo': 'bar', 'baz': 123},
    'quux': ['foo', 'bar', 'baz'],
    'corge': 7,
}""")

    def test_expand_ordered_dict(self):
        dummy_ordered_dict = collections.OrderedDict(
            [
                ("foo", 1),
                ("bar", 12),
                ("baz", 123),
            ]
        )
        self.assertEqual(pprint.pformat(dummy_ordered_dict, width=20, indent=4),
"""\
OrderedDict([
    ('foo', 1),
    ('bar', 12),
    ('baz', 123),
])""")

    def test_expand_list(self):
        dummy_list = [
            "foo",
            "bar",
            "baz",
            "qux",
        ]
        self.assertEqual(pprint.pformat(dummy_list, width=20, indent=4),
"""\
[
    'foo',
    'bar',
    'baz',
    'qux',
]""")

    def test_expand_tuple(self):
        dummy_tuple = (
            "foo",
            "bar",
            "baz",
            4,
            5,
            6,
        )
        self.assertEqual(pprint.pformat(dummy_tuple, width=20, indent=4),
"""\
(
    'foo',
    'bar',
    'baz',
    4,
    5,
    6,
)""")

    def test_expand_single_element_tuple(self):
        self.assertEqual(
            pprint.pformat((1,), width=1, indent=4),
            """\
(
    1,
)""")

    def test_expand_set(self):
        dummy_set = {
            "foo",
            "bar",
            "baz",
            "qux",
            (1, 2, 3),
        }
        self.assertEqual(pprint.pformat(dummy_set, width=20, indent=4),
"""\
{
    'bar',
    'baz',
    'foo',
    'qux',
    (1, 2, 3),
}""")

    def test_expand_frozenset(self):
        dummy_set = {
            (1, 2, 3),
        }
        dummy_frozenset = frozenset(
            {
                "foo",
                "bar",
                "baz",
                (1, 2, 3),
                frozenset(dummy_set),
            }
        )
        self.assertEqual(pprint.pformat(dummy_frozenset, width=40, indent=4),
"""\
frozenset({
    frozenset({(1, 2, 3)}),
    'bar',
    'baz',
    'foo',
    (1, 2, 3),
})""")

    def test_expand_frozendict(self):
        dummy_frozendict = frozendict(
            {"foo": "bar", "baz": 123, "qux": [1, 2]}
        )
        self.assertEqual(
            pprint.pformat(dummy_frozendict, width=20, indent=4),
            """\
frozendict({
    'baz': 123,
    'foo': 'bar',
    'qux': [1, 2],
})""",
        )

    def test_expand_bytes(self):
        dummy_bytes = b"Hello world! foo bar baz 123 456 789"
        self.assertEqual(pprint.pformat(dummy_bytes, width=20, indent=4),
"""\
(
    b'Hello world!'
    b' foo bar baz'
    b' 123 456 789'
)""")

    def test_expand_bytearray(self):
        dummy_bytes = b"Hello world! foo bar baz 123 456 789"
        dummy_byte_array = bytearray(dummy_bytes)
        self.assertEqual(pprint.pformat(dummy_byte_array, width=40, indent=4),
"""\
bytearray(
    b'Hello world! foo bar baz 123 456'
    b' 789'
)""")

    def test_expand_mappingproxy(self):
        dummy_dict = {
            "foo": "bar",
            "baz": 123,
            "qux": {"foo": "bar", "baz": 123},
            "quux": ["foo", "bar", "baz"],
            "corge": 7,
        }
        dummy_mappingproxy = types.MappingProxyType(dummy_dict)
        self.assertEqual(pprint.pformat(dummy_mappingproxy, width=40, indent=4),
"""\
mappingproxy({
    'baz': 123,
    'corge': 7,
    'foo': 'bar',
    'quux': ['foo', 'bar', 'baz'],
    'qux': {'baz': 123, 'foo': 'bar'},
})""")

    def test_expand_namespace(self):
        dummy_namespace = types.SimpleNamespace(
            foo="bar",
            bar=42,
            baz=types.SimpleNamespace(
                x=321,
                y="string",
                d={"foo": True, "bar": "baz"},
            ),
        )

        self.assertEqual(pprint.pformat(dummy_namespace, width=40, indent=4),
"""\
namespace(
    foo='bar',
    bar=42,
    baz=namespace(
        x=321,
        y='string',
        d={'bar': 'baz', 'foo': True},
    ),
)""")

    def test_expand_defaultdict(self):
        dummy_defaultdict = collections.defaultdict(list)
        dummy_defaultdict["foo"].append("bar")
        dummy_defaultdict["foo"].append("baz")
        dummy_defaultdict["foo"].append("qux")
        dummy_defaultdict["bar"] = {"foo": "bar", "baz": None}
        self.assertEqual(pprint.pformat(dummy_defaultdict, width=40, indent=4),
"""\
defaultdict(<class 'list'>, {
    'bar': {'baz': None, 'foo': 'bar'},
    'foo': ['bar', 'baz', 'qux'],
})""")

    def test_expand_counter(self):
        dummy_counter = collections.Counter("abcdeabcdabcaba")
        expected = """\
Counter({
    'a': 5,
    'b': 4,
    'c': 3,
    'd': 2,
    'e': 1,
})"""
        self.assertEqual(pprint.pformat(dummy_counter, width=40, indent=4), expected)

        expected2 = """\
Counter({
  'a': 5,
  'b': 4,
  'c': 3,
  'd': 2,
  'e': 1,
})"""
        self.assertEqual(pprint.pformat(dummy_counter, width=20, indent=2), expected2)

    def test_expand_chainmap(self):
        dummy_dict = {
            "foo": "bar",
            "baz": 123,
            "qux": {"foo": "bar", "baz": 123},
            "quux": ["foo", "bar", "baz"],
            "corge": 7,
        }
        dummy_chainmap = collections.ChainMap(
            {"foo": "bar"},
            {"baz": "qux"},
            {"corge": dummy_dict},
        )
        dummy_chainmap.maps.append({"garply": "waldo"})
        self.assertEqual(pprint.pformat(dummy_chainmap, width=40, indent=4),
"""\
ChainMap(
    {'foo': 'bar'},
    {'baz': 'qux'},
    {
        'corge': {
            'baz': 123,
            'corge': 7,
            'foo': 'bar',
            'quux': ['foo', 'bar', 'baz'],
            'qux': {
                'baz': 123,
                'foo': 'bar',
            },
        },
    },
    {'garply': 'waldo'},
)""")

    def test_expand_deque(self):
        dummy_dict = {
            "foo": "bar",
            "baz": 123,
            "qux": {"foo": "bar", "baz": 123},
            "quux": ["foo", "bar", "baz"],
            "corge": 7,
        }
        dummy_list = [
            "foo",
            "bar",
            "baz",
        ]
        dummy_set = {
            (1, 2, 3),
        }
        dummy_deque = collections.deque(maxlen=10)
        dummy_deque.append("foo")
        dummy_deque.append(123)
        dummy_deque.append(dummy_dict)
        dummy_deque.extend(dummy_list)
        dummy_deque.appendleft(dummy_set)
        self.assertEqual(pprint.pformat(dummy_deque, width=40, indent=4),
"""\
deque([
    {(1, 2, 3)},
    'foo',
    123,
    {
        'baz': 123,
        'corge': 7,
        'foo': 'bar',
        'quux': ['foo', 'bar', 'baz'],
        'qux': {'baz': 123, 'foo': 'bar'},
    },
    'foo',
    'bar',
    'baz',
], maxlen=10)""")

    def test_expand_userdict(self):
        class DummyUserDict(collections.UserDict):
            """A custom UserDict with some extra attributes"""

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.access_count = 0
        dummy_userdict = DummyUserDict({ "foo": "bar", "baz": 123,
                                        "qux": {"foo": "bar", "baz": 123},
                                        "quux": ["foo", "bar", "baz"],
                                        "corge": 7 })
        dummy_userdict.access_count = 5

        self.assertEqual(pprint.pformat(dummy_userdict, width=40, indent=4),
"""\
{
    'baz': 123,
    'corge': 7,
    'foo': 'bar',
    'quux': ['foo', 'bar', 'baz'],
    'qux': {'baz': 123, 'foo': 'bar'},
}""")

    def test_expand_userlist(self):
        class DummyUserList(collections.UserList):
            """A custom UserList with some extra attributes"""

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.description = "foo"
        dummy_userlist = DummyUserList(["first", 2, {"key": "value"},
                                       [4, 5, 6]])

        self.assertEqual(pprint.pformat(dummy_userlist, width=40, indent=4),
"""\
[
    'first',
    2,
    {'key': 'value'},
    [4, 5, 6],
]""")

    def test_expand_dict_keys(self):
        d = {"foo": 1, "bar": 2, "baz": 3, "qux": 4, "quux": 5}
        self.assertEqual(
            pprint.pformat(d.keys(), width=20, indent=4),
            """\
dict_keys([
    'bar',
    'baz',
    'foo',
    'quux',
    'qux',
])""",
        )

    def test_expand_dict_values(self):
        d = {"foo": 1, "bar": 2, "baz": 3, "qux": 4, "quux": 5}
        self.assertEqual(
            pprint.pformat(d.values(), width=20, indent=4),
            """\
dict_values([
    1,
    2,
    3,
    4,
    5,
])""",
        )

    def test_expand_dict_items(self):
        d = {"foo": 1, "bar": 2, "baz": 3, "qux": 4, "quux": 5}
        self.assertEqual(
            pprint.pformat(d.items(), width=20, indent=4),
            """\
dict_items([
    ('bar', 2),
    ('baz', 3),
    ('foo', 1),
    ('quux', 5),
    ('qux', 4),
])""",
        )

    def test_expand_str(self):
        s = "The quick brown fox jumped over the lazy dog " * 3
        self.assertEqual(
            pprint.pformat(s, width=40, indent=4),
            """\
(
    'The quick brown fox jumped over '
    'the lazy dog The quick brown fox '
    'jumped over the lazy dog The '
    'quick brown fox jumped over the '
    '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()