Exemplo n.º 1
0
    def test_factory(self):
        Point = namedtuple('Point', 'x y')
        self.assertEqual(Point.__name__, 'Point')
        self.assertEqual(Point.__slots__, ())
        self.assertEqual(Point.__module__, __name__)
        self.assertEqual(Point.__getitem__, tuple.__getitem__)
        self.assertEqual(Point._fields, ('x', 'y'))

        self.assertRaises(ValueError, namedtuple, 'abc%',
                          'efg ghi')  # type has non-alpha char
        self.assertRaises(ValueError, namedtuple, 'class',
                          'efg ghi')  # type has keyword
        self.assertRaises(ValueError, namedtuple, '9abc',
                          'efg ghi')  # type starts with digit

        self.assertRaises(ValueError, namedtuple, 'abc',
                          'efg g%hi')  # field with non-alpha char
        self.assertRaises(ValueError, namedtuple, 'abc',
                          'abc class')  # field has keyword
        self.assertRaises(ValueError, namedtuple, 'abc',
                          '8efg 9ghi')  # field starts with digit
        self.assertRaises(ValueError, namedtuple, 'abc',
                          '_efg ghi')  # field with leading underscore
        self.assertRaises(ValueError, namedtuple, 'abc',
                          'efg efg ghi')  # duplicate field

        namedtuple('Point0',
                   'x1 y2')  # Verify that numbers are allowed in names
        namedtuple('_', 'a b c')  # Test leading underscores in a typename

        self.assertRaises(TypeError, Point._make, [11])  # catch too few args
        self.assertRaises(TypeError, Point._make,
                          [11, 22, 33])  # catch too many args
Exemplo n.º 2
0
 def test_name_fixer(self):
     for spec, renamed in [
         [('efg', 'g%hi'), ('efg', '_1')],                              # field with non-alpha char
         [('abc', 'class'), ('abc', '_1')],                              # field has keyword
         [('8efg', '9ghi'), ('_0', '_1')],                               # field starts with digit
         [('abc', '_efg'), ('abc', '_1')],                               # field with leading underscore
         [('abc', 'efg', 'efg', 'ghi'), ('abc', 'efg', '_2', 'ghi')],    # duplicate field
         [('abc', '', 'x'), ('abc', '_1', 'x')],                         # fieldname is a space
     ]:
         self.assertEqual(namedtuple('NT', spec, rename=True)._fields, renamed)
Exemplo n.º 3
0
    def test_odd_sizes(self):
        Zero = namedtuple('Zero', '')
        self.assertEqual(Zero(), ())
        self.assertEqual(Zero._make([]), ())
        self.assertEqual(repr(Zero()), 'Zero()')
        self.assertEqual(Zero()._asdict(), {})
        self.assertEqual(Zero()._fields, ())

        Dot = namedtuple('Dot', 'd')
        self.assertEqual(Dot(1), (1, ))
        self.assertEqual(Dot._make([1]), (1, ))
        self.assertEqual(Dot(1).d, 1)
        self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
        self.assertEqual(Dot(1)._asdict(), {'d': 1})
        self.assertEqual(Dot(1)._replace(d=999), (999, ))
        self.assertEqual(Dot(1)._fields, ('d', ))

        n = 5000
        import string
        import random
        names = list(
            set(''.join(
                [random.choice(string.ascii_letters) for j in range(10)])
                for i in range(n)))
        n = len(names)
        Big = namedtuple('Big', names)
        b = Big(*range(n))
        self.assertEqual(b, tuple(range(n)))
        self.assertEqual(Big._make(range(n)), tuple(range(n)))
        for pos, name in enumerate(names):
            self.assertEqual(getattr(b, name), pos)
        repr(b)  # make sure repr() doesn't blow-up
        d = b._asdict()
        d_expected = dict(zip(names, range(n)))
        self.assertEqual(d, d_expected)
        b2 = b._replace(**dict([(names[1], 999), (names[-5], 42)]))
        b2_expected = range(n)
        b2_expected[1] = 999
        b2_expected[-5] = 42
        self.assertEqual(b2, tuple(b2_expected))
        self.assertEqual(b._fields, tuple(names))
Exemplo n.º 4
0
 def test_name_fixer(self):
     for spec, renamed in [
         [('efg', 'g%hi'), ('efg', '_1')],  # field with non-alpha char
         [('abc', 'class'), ('abc', '_1')],  # field has keyword
         [('8efg', '9ghi'), ('_0', '_1')],  # field starts with digit
         [('abc', '_efg'), ('abc', '_1')],  # field with leading underscore
         [('abc', 'efg', 'efg', 'ghi'),
          ('abc', 'efg', '_2', 'ghi')],  # duplicate field
         [('abc', '', 'x'), ('abc', '_1', 'x')],  # fieldname is a space
     ]:
         self.assertEqual(
             namedtuple('NT', spec, rename=True)._fields, renamed)
Exemplo n.º 5
0
    def test_odd_sizes(self):
        Zero = namedtuple('Zero', '')
        self.assertEqual(Zero(), ())
        self.assertEqual(Zero._make([]), ())
        self.assertEqual(repr(Zero()), 'Zero()')
        self.assertEqual(Zero()._asdict(), {})
        self.assertEqual(Zero()._fields, ())

        Dot = namedtuple('Dot', 'd')
        self.assertEqual(Dot(1), (1,))
        self.assertEqual(Dot._make([1]), (1,))
        self.assertEqual(Dot(1).d, 1)
        self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
        self.assertEqual(Dot(1)._asdict(), {'d': 1})
        self.assertEqual(Dot(1)._replace(d=999), (999,))
        self.assertEqual(Dot(1)._fields, ('d',))

        n = 5000
        import string
        import random
        names = list(set(''.join([random.choice(string.ascii_letters)
                                  for j in range(10)]) for i in range(n)))
        n = len(names)
        Big = namedtuple('Big', names)
        b = Big(*range(n))
        self.assertEqual(b, tuple(range(n)))
        self.assertEqual(Big._make(range(n)), tuple(range(n)))
        for pos, name in enumerate(names):
            self.assertEqual(getattr(b, name), pos)
        repr(b)                                 # make sure repr() doesn't blow-up
        d = b._asdict()
        d_expected = dict(zip(names, range(n)))
        self.assertEqual(d, d_expected)
        b2 = b._replace(**dict([(names[1], 999), (names[-5], 42)]))
        b2_expected = range(n)
        b2_expected[1] = 999
        b2_expected[-5] = 42
        self.assertEqual(b2, tuple(b2_expected))
        self.assertEqual(b._fields, tuple(names))
Exemplo n.º 6
0
    def test_instance(self):
        Point = namedtuple('Point', 'x y')
        p = Point(11, 22)
        self.assertEqual(p, Point(x=11, y=22))
        self.assertEqual(p, Point(11, y=22))
        self.assertEqual(p, Point(y=22, x=11))
        self.assertEqual(p, Point(*(11, 22)))
        self.assertEqual(p, Point(**dict(x=11, y=22)))
        self.assertRaises(TypeError, Point, 1)  # too few args
        self.assertRaises(TypeError, Point, 1, 2, 3)  # too many args
        self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)',
                          locals())  # wrong keyword argument
        self.assertRaises(TypeError, eval, 'Point(x=1)',
                          locals())  # missing keyword argument
        self.assertEqual(repr(p), 'Point(x=11, y=22)')
        self.assertNotIn('__weakref__', dir(p))
        self.assertEqual(p, Point._make([11, 22]))  # test _make classmethod
        self.assertEqual(p._fields, ('x', 'y'))  # test _fields attribute
        self.assertEqual(p._replace(x=1), (1, 22))  # test _replace method
        self.assertEqual(p._asdict(), dict(x=11, y=22))  # test _asdict method
        self.assertEqual(vars(p), p._asdict())  # verify that vars() works

        try:
            p._replace(x=1, error=2)
        except ValueError:
            pass
        else:
            self._fail('Did not detect an incorrect fieldname')

        # verify that field string can have commas
        Point = namedtuple('Point', 'x, y')
        p = Point(x=11, y=22)
        self.assertEqual(repr(p), 'Point(x=11, y=22)')

        # verify that fieldspec can be a non-string sequence
        Point = namedtuple('Point', ('x', 'y'))
        p = Point(x=11, y=22)
        self.assertEqual(repr(p), 'Point(x=11, y=22)')
Exemplo n.º 7
0
    def test_factory(self):
        Point = namedtuple('Point', 'x y')
        self.assertEqual(Point.__name__, 'Point')
        self.assertEqual(Point.__slots__, ())
        self.assertEqual(Point.__module__, __name__)
        self.assertEqual(Point.__getitem__, tuple.__getitem__)
        self.assertEqual(Point._fields, ('x', 'y'))

        self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi')       # type has non-alpha char
        self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi')      # type has keyword
        self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi')       # type starts with digit

        self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi')       # field with non-alpha char
        self.assertRaises(ValueError, namedtuple, 'abc', 'abc class')      # field has keyword
        self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi')      # field starts with digit
        self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi')       # field with leading underscore
        self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi')    # duplicate field

        namedtuple('Point0', 'x1 y2')   # Verify that numbers are allowed in names
        namedtuple('_', 'a b c')        # Test leading underscores in a typename

        self.assertRaises(TypeError, Point._make, [11])                     # catch too few args
        self.assertRaises(TypeError, Point._make, [11, 22, 33])             # catch too many args
Exemplo n.º 8
0
    def test_instance(self):
        Point = namedtuple('Point', 'x y')
        p = Point(11, 22)
        self.assertEqual(p, Point(x=11, y=22))
        self.assertEqual(p, Point(11, y=22))
        self.assertEqual(p, Point(y=22, x=11))
        self.assertEqual(p, Point(*(11, 22)))
        self.assertEqual(p, Point(**dict(x=11, y=22)))
        self.assertRaises(TypeError, Point, 1)                              # too few args
        self.assertRaises(TypeError, Point, 1, 2, 3)                        # too many args
        self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals())   # wrong keyword argument
        self.assertRaises(TypeError, eval, 'Point(x=1)', locals())          # missing keyword argument
        self.assertEqual(repr(p), 'Point(x=11, y=22)')
        self.assertNotIn('__weakref__', dir(p))
        self.assertEqual(p, Point._make([11, 22]))                          # test _make classmethod
        self.assertEqual(p._fields, ('x', 'y'))                             # test _fields attribute
        self.assertEqual(p._replace(x=1), (1, 22))                          # test _replace method
        self.assertEqual(p._asdict(), dict(x=11, y=22))                     # test _asdict method
        self.assertEqual(vars(p), p._asdict())                              # verify that vars() works

        try:
            p._replace(x=1, error=2)
        except ValueError:
            pass
        else:
            self._fail('Did not detect an incorrect fieldname')

        # verify that field string can have commas
        Point = namedtuple('Point', 'x, y')
        p = Point(x=11, y=22)
        self.assertEqual(repr(p), 'Point(x=11, y=22)')

        # verify that fieldspec can be a non-string sequence
        Point = namedtuple('Point', ('x', 'y'))
        p = Point(x=11, y=22)
        self.assertEqual(repr(p), 'Point(x=11, y=22)')
Exemplo n.º 9
0
    def test_tupleness(self):
        Point = namedtuple('Point', 'x y')
        p = Point(11, 22)

        self.assertIsInstance(p, tuple)
        self.assertEqual(p, (11, 22))  # matches a real tuple
        self.assertEqual(tuple(p), (11, 22))  # coercable to a real tuple
        self.assertEqual(list(p), [11, 22])  # coercable to a list
        self.assertEqual(max(p), 22)  # iterable
        self.assertEqual(max(*p), 22)  # star-able
        x, y = p
        self.assertEqual(p, (x, y))  # unpacks like a tuple
        self.assertEqual((p[0], p[1]), (11, 22))  # indexable like a tuple
        self.assertRaises(IndexError, p.__getitem__, 3)

        self.assertEqual(p.x, x)
        self.assertEqual(p.y, y)
        self.assertRaises(AttributeError, eval, 'p.z', locals())
Exemplo n.º 10
0
    def test_tupleness(self):
        Point = namedtuple('Point', 'x y')
        p = Point(11, 22)

        self.assertIsInstance(p, tuple)
        self.assertEqual(p, (11, 22))                                       # matches a real tuple
        self.assertEqual(tuple(p), (11, 22))                                # coercable to a real tuple
        self.assertEqual(list(p), [11, 22])                                 # coercable to a list
        self.assertEqual(max(p), 22)                                        # iterable
        self.assertEqual(max(*p), 22)                                       # star-able
        x, y = p
        self.assertEqual(p, (x, y))                                         # unpacks like a tuple
        self.assertEqual((p[0], p[1]), (11, 22))                            # indexable like a tuple
        self.assertRaises(IndexError, p.__getitem__, 3)

        self.assertEqual(p.x, x)
        self.assertEqual(p.y, y)
        self.assertRaises(AttributeError, eval, 'p.z', locals())
Exemplo n.º 11
0
 def test_factory_doc_attr(self):
     Point = namedtuple('Point', 'x y')
     self.assertEqual(Point.__doc__, 'Point(x, y)')
Exemplo n.º 12
0
import unittest

try:
    import cPickle
    pickles = [pickle, cPickle]
except ImportError:
    pickles = [pickle]

from six import PY2

from smarkets.collections import namedtuple

# This is namedtuple backported from CPython 2.7.5, it fixes http://bugs.python.org/issue15535
# Copyright © 2001-2014 Python Software Foundation; All Rights Reserved

TestNT = namedtuple('TestNT', 'x y z')  # type used for pickle tests

py273_named_tuple_pickle = b'''\
ccopy_reg
_reconstructor
p0
(csmarkets.tests.collections
TestNT
p1
c__builtin__
tuple
p2
(I10
I20
I30
tp3
Exemplo n.º 13
0
 def test_factory_doc_attr(self):
     Point = namedtuple('Point', 'x y')
     self.assertEqual(Point.__doc__, 'Point(x, y)')
Exemplo n.º 14
0
try:
    import cPickle
    pickles = [pickle, cPickle]
except ImportError:
    pickles = [pickle]

from six import PY2

from smarkets.collections import namedtuple

# This is namedtuple backported from CPython 2.7.5, it fixes http://bugs.python.org/issue15535
# Copyright © 2001-2014 Python Software Foundation; All Rights Reserved


TestNT = namedtuple('TestNT', 'x y z')    # type used for pickle tests

py273_named_tuple_pickle = b'''\
ccopy_reg
_reconstructor
p0
(csmarkets.tests.collections
TestNT
p1
c__builtin__
tuple
p2
(I10
I20
I30
tp3