def test_sizeof(self):
     basesize = support.calcobjsize('P2nN2Pn')
     check = self.check_sizeof
     self.assertEqual(object.__sizeof__(io.BytesIO()), basesize)
     check(io.BytesIO(), basesize )
     check(io.BytesIO(b'a'), basesize + 1 + 1 )
     check(io.BytesIO(b'a' * 1000), basesize + 1000 + 1 )

    def test_sizeof(self):
        def XXXROUNDUP(n):
            if n <= 1:
                return n
            if n <= 128:
                return (n + 3) & ~3
            return 1 << (n - 1).bit_length()

        basesize = support.calcobjsize('Pii')
        nodesize = struct.calcsize('hP3iP0h')
        def sizeofchildren(node):
            if node is None:
                return 0
            res = 0
            hasstr = len(node) > 1 and isinstance(node[-1], str)
            if hasstr:
                res += len(node[-1]) + 1
            children = node[1:-1] if hasstr else node[1:]
            if children:
                res += XXXROUNDUP(len(children)) * nodesize
                for child in children:
                    res += sizeofchildren(child)
            return res

        def check_st_sizeof(st):
            self.check_sizeof(st, basesize + nodesize +
                                  sizeofchildren(st.totuple()))

        check_st_sizeof(parser.expr('2 + 3'))
        check_st_sizeof(parser.expr('2 + 3 + 4'))
        check_st_sizeof(parser.suite('x = 2 + 3'))
        check_st_sizeof(parser.suite(''))
        check_st_sizeof(parser.suite('# -*- coding: utf-8 -*-'))
        check_st_sizeof(parser.expr('[' + '2,' * 1000 + ']'))

 def test_sizeof(self):
     basesize = support.calcobjsize('P2n2Pn')
     check = self.check_sizeof
     self.assertEqual(object.__sizeof__(io.BytesIO()), basesize)
     check(io.BytesIO(), basesize )
     n = 1000  # use a variable to prevent constant folding
     check(io.BytesIO(b'a' * n), basesize + sys.getsizeof(b'a' * n))

 def test_sizeof(self):
     BLOCKLEN = 62
     basesize = support.calcobjsize('2P4nlP')
     blocksize = struct.calcsize('2P%dP' % BLOCKLEN)
     self.assertEqual(object.__sizeof__(deque()), basesize)
     check = self.check_sizeof
     check(deque(), basesize + blocksize)
     check(deque('a'), basesize + blocksize)
     check(deque('a' * (BLOCKLEN - 1)), basesize + blocksize)
     check(deque('a' * BLOCKLEN), basesize + 2 * blocksize)
     check(deque('a' * (42 * BLOCKLEN)), basesize + 43 * blocksize)

 def test_sizeof(self):
     BLOCKLEN = 62
     basesize = support.calcobjsize("2P4nlP")
     blocksize = struct.calcsize("2P%dP" % BLOCKLEN)
     self.assertEqual(object.__sizeof__(deque()), basesize)
     check = self.check_sizeof
     check(deque(), basesize + blocksize)
     check(deque("a"), basesize + blocksize)
     check(deque("a" * (BLOCKLEN // 2)), basesize + blocksize)
     check(deque("a" * (BLOCKLEN // 2 + 1)), basesize + 2 * blocksize)
     check(deque("a" * (42 * BLOCKLEN)), basesize + 43 * blocksize)

 def test_pickler(self):
     basesize = support.calcobjsize('5P2n3i2n3iP')
     p = _pickle.Pickler(io.BytesIO())
     self.assertEqual(object.__sizeof__(p), basesize)
     MT_size = struct.calcsize('3nP0n')
     ME_size = struct.calcsize('Pn0P')
     check = self.check_sizeof
     check(p, basesize +
         MT_size + 8 * ME_size +  # Minimal memo table size.
         sys.getsizeof(b'x'*4096))  # Minimal write buffer size.
     for i in range(6):
         p.dump(chr(i))
     check(p, basesize +
         MT_size + 32 * ME_size +  # Size of memo table required to
                                   # save references to 6 objects.
         0)  # Write buffer is cleared after every dump().

        def test_unpickler(self):
            basesize = support.calcobjsize('2Pn2P 2P2n2i5P 2P3n6P2n2i')
            unpickler = _pickle.Unpickler
            P = struct.calcsize('P')  # Size of memo table entry.
            n = struct.calcsize('n')  # Size of mark table entry.
            check = self.check_sizeof
            for encoding in 'ASCII', 'UTF-16', 'latin-1':
                for errors in 'strict', 'replace':
                    u = unpickler(io.BytesIO(),
                                  encoding=encoding, errors=errors)
                    self.assertEqual(object.__sizeof__(u), basesize)
                    check(u, basesize +
                             32 * P +  # Minimal memo table size.
                             len(encoding) + 1 + len(errors) + 1)

            stdsize = basesize + len('ASCII') + 1 + len('strict') + 1
            def check_unpickler(data, memo_size, marks_size):
                dump = pickle.dumps(data)
                u = unpickler(io.BytesIO(dump),
                              encoding='ASCII', errors='strict')
                u.load()
                check(u, stdsize + memo_size * P + marks_size * n)

            check_unpickler(0, 32, 0)
            # 20 is minimal non-empty mark stack size.
            check_unpickler([0] * 100, 32, 20)
            # 128 is memo table size required to save references to 100 objects.
            check_unpickler([chr(i) for i in range(100)], 128, 20)
            def recurse(deep):
                data = 0
                for i in range(deep):
                    data = [data, data]
                return data
            check_unpickler(recurse(0), 32, 0)
            check_unpickler(recurse(1), 32, 20)
            check_unpickler(recurse(20), 32, 58)
            check_unpickler(recurse(50), 64, 58)
            check_unpickler(recurse(100), 128, 134)

            u = unpickler(io.BytesIO(pickle.dumps('a', 0)),
                          encoding='ASCII', errors='strict')
            u.load()
            check(u, stdsize + 32 * P + 2 + 1)

 def setUp(self):
     self.elementsize = support.calcobjsize('5P')
     # extra
     self.extra = struct.calcsize('PiiP4P')

 def check_sizeof(self, format_str, number_of_codes):
     # The size of 'PyStructObject'
     totalsize = support.calcobjsize('2n3P')
     # The size taken up by the 'formatcode' dynamic array
     totalsize += struct.calcsize('P3n0P') * (number_of_codes + 1)
     support.check_sizeof(self, struct.Struct(format_str), totalsize)