# Simplify merging from upstream: use the old name.
import buck.pprint as pprint
import unittest

try:
    uni = unicode
except NameError:
    def uni(x):
        return x

# 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 dict2(dict):
    pass

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

def powerset(U):
    """Generates all subsets of a set or sequence U."""
    U = iter(U)
    try:
        x = frozenset([U.next()])
        for S in powerset(U):
            yield S
            yield S | x
    except StopIteration:
        yield frozenset()

def cube(n):
    """Graph of n-dimensional hypercube."""
    singletons = [frozenset([x]) for x in range(n)]
    return dict([(x, frozenset([x^s for s in singletons]))
                 for x in powerset(range(n))])

def linegraph(G):
    """Graph, the vertices of which are edges of G,
    with two vertices being adjacent iff the corresponding
    edges share a vertex."""
    L = {}
    for x in G:
        for y in G[x]:
            nx = [frozenset([x,z]) for z in G[x] if z != y]
            ny = [frozenset([y,z]) for z in G[y] if z != x]
            L[frozenset([x,y])] = frozenset(nx+ny)
    return L

class QueryTestCase(unittest.TestCase):

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

    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}, uni("yaddayadda"),
                     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, 0L, 0+0j, 0.0, "", uni(""),
                       (), tuple2(), tuple3(),
                       [], list2(), list3(),
                       {}, dict2(), dict3(),
                       self.assertTrue, pprint,
                       -6, -6L, -6-6j, -1.5, "x", uni("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)),
                       dict2({5: 6}), dict3({5: 6}),
                       range(10, -11, -1)
                      ):
            native = repr(simple)
            for function in "pformat", "saferepr":
                f = getattr(pprint, function)
                got = f(simple)
                self.assertEqual(native, got,
                                 "expected %s got %s from pprint.%s" %
                                 (native, got, function))

    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]:
            act = pprint.pformat(type(o))
            self.assertEqual(act , exp)

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

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

        # indent parameter
        o = range(100)
        exp = '[\n %s,\n]' % ',\n '.join(map(str, o))
        for type in [list, list2]:
            self.assertEqual(pprint.pformat(type(o), indent=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,
    },
]"""
        actual = pprint.pformat(o, indent=4, width=42)
        self.assertEqual(actual, expected)

    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_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))), 'set([0, 1, 2])')
        self.assertEqual(pprint.pformat(frozenset()), 'frozenset()')
        self.assertEqual(pprint.pformat(frozenset(range(3))), 'frozenset([0, 1, 2])')
        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]),
    ]),
}"""
        my_cube = cube(3)
        actual = pprint.pformat(my_cube)
        self.assertEqual(actual, 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 = linegraph(my_cube)
        actual = pprint.pformat(cubo)
        self.assertEqual(actual, 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)


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()
# vim:et:sts=4:sw=4:
