Lib/test/test_struct.py

   1 from test.test_support import TestFailed, verbose, verify, vereq
   2 import test.test_support
   3 import struct
   4 import array
   5 import warnings
   6
   7 import sys
   8 ISBIGENDIAN = sys.byteorder == "big"
   9 del sys
  10 verify((struct.pack('=i', 1)[0] == chr(0)) == ISBIGENDIAN,
  11        "bigendian determination appears wrong")
  12
  13 try:
  14     import _struct
  15 except ImportError:
  16     PY_STRUCT_RANGE_CHECKING = 0
  17     PY_STRUCT_OVERFLOW_MASKING = 1
  18     PY_STRUCT_FLOAT_COERCE = 2
  19 else:
  20     PY_STRUCT_RANGE_CHECKING = getattr(_struct, '_PY_STRUCT_RANGE_CHECKING', 0)
  21     PY_STRUCT_OVERFLOW_MASKING = getattr(_struct, '_PY_STRUCT_OVERFLOW_MASKING', 0)
  22     PY_STRUCT_FLOAT_COERCE = getattr(_struct, '_PY_STRUCT_FLOAT_COERCE', 0)
  23
  24 def string_reverse(s):
  25     return "".join(reversed(s))
  26
  27 def bigendian_to_native(value):
  28     if ISBIGENDIAN:
  29         return value
  30     else:
  31         return string_reverse(value)
  32
  33 def simple_err(func, *args):
  34     try:
  35         func(*args)
  36     except struct.error:
  37         pass
  38     else:
  39         raise TestFailed, "%s%s did not raise struct.error" % (
  40             func.__name__, args)
  41
  42 def any_err(func, *args):
  43     try:
  44         func(*args)
  45     except (struct.error, TypeError):
  46         pass
  47     else:
  48         raise TestFailed, "%s%s did not raise error" % (
  49             func.__name__, args)
  50
  51 def with_warning_restore(func):
  52     def _with_warning_restore(*args, **kw):
  53         with test.test_support.catch_warning():
  54             # Grrr, we need this function to warn every time.  Without removing
  55             # the warningregistry, running test_tarfile then test_struct would fail
  56             # on 64-bit platforms.
  57             globals = func.func_globals
  58             if '__warningregistry__' in globals:
  59                 del globals['__warningregistry__']
  60             warnings.filterwarnings("error", r"""^struct.*""", DeprecationWarning)
  61             warnings.filterwarnings("error", r""".*format requires.*""",
  62                                     DeprecationWarning)
  63             return func(*args, **kw)
  64     return _with_warning_restore
  65
  66 def deprecated_err(func, *args):
  67     try:
  68         func(*args)
  69     except (struct.error, TypeError):
  70         pass
  71     except DeprecationWarning:
  72         if not PY_STRUCT_OVERFLOW_MASKING:
  73             raise TestFailed, "%s%s expected to raise struct.error" % (
  74                 func.__name__, args)
  75     else:
  76         raise TestFailed, "%s%s did not raise error" % (
  77             func.__name__, args)
  78 deprecated_err = with_warning_restore(deprecated_err)
  79
  80
  81 simple_err(struct.calcsize, 'Z')
  82
  83 sz = struct.calcsize('i')
  84 if sz * 3 != struct.calcsize('iii'):
  85     raise TestFailed, 'inconsistent sizes'
  86
  87 fmt = 'cbxxxxxxhhhhiillffdt'
  88 fmt3 = '3c3b18x12h6i6l6f3d3t'
  89 sz = struct.calcsize(fmt)
  90 sz3 = struct.calcsize(fmt3)
  91 if sz * 3 != sz3:
  92     raise TestFailed, 'inconsistent sizes (3*%r -> 3*%d = %d, %r -> %d)' % (
  93         fmt, sz, 3*sz, fmt3, sz3)
  94
  95 simple_err(struct.pack, 'iii', 3)
  96 simple_err(struct.pack, 'i', 3, 3, 3)
  97 simple_err(struct.pack, 'i', 'foo')
  98 simple_err(struct.pack, 'P', 'foo')
  99 simple_err(struct.unpack, 'd', 'flap')
 100 s = struct.pack('ii', 1, 2)
 101 simple_err(struct.unpack, 'iii', s)
 102 simple_err(struct.unpack, 'i', s)
 103
 104 c = 'a'
 105 b = 1
 106 h = 255
 107 i = 65535
 108 l = 65536
 109 f = 3.1415
 110 d = 3.1415
 111 t = True
 112
 113 for prefix in ('', '@', '<', '>', '=', '!'):
 114     for format in ('xcbhilfdt', 'xcBHILfdt'):
 115         format = prefix + format
 116         if verbose:
 117             print "trying:", format
 118         s = struct.pack(format, c, b, h, i, l, f, d, t)
 119         cp, bp, hp, ip, lp, fp, dp, tp = struct.unpack(format, s)
 120         if (cp != c or bp != b or hp != h or ip != i or lp != l or
 121             int(100 * fp) != int(100 * f) or int(100 * dp) != int(100 * d) or
 122                         tp != t):
 123             # ^^^ calculate only to two decimal places
 124             raise TestFailed, "unpack/pack not transitive (%s, %s)" % (
 125                 str(format), str((cp, bp, hp, ip, lp, fp, dp, tp)))
 126
 127 # Test some of the new features in detail
 128
 129 # (format, argument, big-endian result, little-endian result, asymmetric)
 130 tests = [
 131     ('c', 'a', 'a', 'a', 0),
 132     ('xc', 'a', '\0a', '\0a', 0),
 133     ('cx', 'a', 'a\0', 'a\0', 0),
 134     ('s', 'a', 'a', 'a', 0),
 135     ('0s', 'helloworld', '', '', 1),
 136     ('1s', 'helloworld', 'h', 'h', 1),
 137     ('9s', 'helloworld', 'helloworl', 'helloworl', 1),
 138     ('10s', 'helloworld', 'helloworld', 'helloworld', 0),
 139     ('11s', 'helloworld', 'helloworld\0', 'helloworld\0', 1),
 140     ('20s', 'helloworld', 'helloworld'+10*'\0', 'helloworld'+10*'\0', 1),
 141     ('b', 7, '\7', '\7', 0),
 142     ('b', -7, '\371', '\371', 0),
 143     ('B', 7, '\7', '\7', 0),
 144     ('B', 249, '\371', '\371', 0),
 145     ('h', 700, '\002\274', '\274\002', 0),
 146     ('h', -700, '\375D', 'D\375', 0),
 147     ('H', 700, '\002\274', '\274\002', 0),
 148     ('H', 0x10000-700, '\375D', 'D\375', 0),
 149     ('i', 70000000, '\004,\035\200', '\200\035,\004', 0),
 150     ('i', -70000000, '\373\323\342\200', '\200\342\323\373', 0),
 151     ('I', 70000000L, '\004,\035\200', '\200\035,\004', 0),
 152     ('I', 0x100000000L-70000000, '\373\323\342\200', '\200\342\323\373', 0),
 153     ('l', 70000000, '\004,\035\200', '\200\035,\004', 0),
 154     ('l', -70000000, '\373\323\342\200', '\200\342\323\373', 0),
 155     ('L', 70000000L, '\004,\035\200', '\200\035,\004', 0),
 156     ('L', 0x100000000L-70000000, '\373\323\342\200', '\200\342\323\373', 0),
 157     ('f', 2.0, '@\000\000\000', '\000\000\000@', 0),
 158     ('d', 2.0, '@\000\000\000\000\000\000\000',
 159                '\000\000\000\000\000\000\000@', 0),
 160     ('f', -2.0, '\300\000\000\000', '\000\000\000\300', 0),
 161     ('d', -2.0, '\300\000\000\000\000\000\000\000',
 162                '\000\000\000\000\000\000\000\300', 0),
 163         ('t', 0, '\0', '\0', 0),
 164         ('t', 3, '\1', '\1', 1),
 165         ('t', True, '\1', '\1', 0),
 166         ('t', [], '\0', '\0', 1),
 167         ('t', (1,), '\1', '\1', 1),
 168 ]
 169
 170 for fmt, arg, big, lil, asy in tests:
 171     if verbose:
 172         print "%r %r %r %r" % (fmt, arg, big, lil)
 173     for (xfmt, exp) in [('>'+fmt, big), ('!'+fmt, big), ('<'+fmt, lil),
 174                         ('='+fmt, ISBIGENDIAN and big or lil)]:
 175         res = struct.pack(xfmt, arg)
 176         if res != exp:
 177             raise TestFailed, "pack(%r, %r) -> %r # expected %r" % (
 178                 fmt, arg, res, exp)
 179         n = struct.calcsize(xfmt)
 180         if n != len(res):
 181             raise TestFailed, "calcsize(%r) -> %d # expected %d" % (
 182                 xfmt, n, len(res))
 183         rev = struct.unpack(xfmt, res)[0]
 184         if rev != arg and not asy:
 185             raise TestFailed, "unpack(%r, %r) -> (%r,) # expected (%r,)" % (
 186                 fmt, res, rev, arg)
 187
 188 ###########################################################################
 189 # Simple native q/Q tests.
 190
 191 has_native_qQ = 1
 192 try:
 193     struct.pack("q", 5)
 194 except struct.error:
 195     has_native_qQ = 0
 196
 197 if verbose:
 198     print "Platform has native q/Q?", has_native_qQ and "Yes." or "No."
 199
 200 any_err(struct.pack, "Q", -1)   # can't pack -1 as unsigned regardless
 201 simple_err(struct.pack, "q", "a")  # can't pack string as 'q' regardless
 202 simple_err(struct.pack, "Q", "a")  # ditto, but 'Q'
 203
 204 def test_native_qQ():
 205     bytes = struct.calcsize('q')
 206     # The expected values here are in big-endian format, primarily because
 207     # I'm on a little-endian machine and so this is the clearest way (for
 208     # me) to force the code to get exercised.
 209     for format, input, expected in (
 210             ('q', -1, '\xff' * bytes),
 211             ('q', 0, '\x00' * bytes),
 212             ('Q', 0, '\x00' * bytes),
 213             ('q', 1L, '\x00' * (bytes-1) + '\x01'),
 214             ('Q', (1L << (8*bytes))-1, '\xff' * bytes),
 215             ('q', (1L << (8*bytes-1))-1, '\x7f' + '\xff' * (bytes - 1))):
 216         got = struct.pack(format, input)
 217         native_expected = bigendian_to_native(expected)
 218         verify(got == native_expected,
 219                "%r-pack of %r gave %r, not %r" %
 220                     (format, input, got, native_expected))
 221         retrieved = struct.unpack(format, got)[0]
 222         verify(retrieved == input,
 223                "%r-unpack of %r gave %r, not %r" %
 224                     (format, got, retrieved, input))
 225
 226 if has_native_qQ:
 227     test_native_qQ()
 228
 229 ###########################################################################
 230 # Standard integer tests (bBhHiIlLqQ).
 231
 232 import binascii
 233
 234 class IntTester:
 235
 236     # XXX Most std integer modes fail to test for out-of-range.
 237     # The "i" and "l" codes appear to range-check OK on 32-bit boxes, but
 238     # fail to check correctly on some 64-bit ones (Tru64 Unix + Compaq C
 239     # reported by Mark Favas).
 240     BUGGY_RANGE_CHECK = "bBhHiIlL"
 241
 242     def __init__(self, formatpair, bytesize):
 243         assert len(formatpair) == 2
 244         self.formatpair = formatpair
 245         for direction in "<>!=":
 246             for code in formatpair:
 247                 format = direction + code
 248                 verify(struct.calcsize(format) == bytesize)
 249         self.bytesize = bytesize
 250         self.bitsize = bytesize * 8
 251         self.signed_code, self.unsigned_code = formatpair
 252         self.unsigned_min = 0
 253         self.unsigned_max = 2L**self.bitsize - 1
 254         self.signed_min = -(2L**(self.bitsize-1))
 255         self.signed_max = 2L**(self.bitsize-1) - 1
 256
 257     def test_one(self, x, pack=struct.pack,
 258                           unpack=struct.unpack,
 259                           unhexlify=binascii.unhexlify):
 260         if verbose:
 261             print "trying std", self.formatpair, "on", x, "==", hex(x)
 262
 263         # Try signed.
 264         code = self.signed_code
 265         if self.signed_min <= x <= self.signed_max:
 266             # Try big-endian.
 267             expected = long(x)
 268             if x < 0:
 269                 expected += 1L << self.bitsize
 270                 assert expected > 0
 271             expected = hex(expected)[2:-1] # chop "0x" and trailing 'L'
 272             if len(expected) & 1:
 273                 expected = "0" + expected
 274             expected = unhexlify(expected)
 275             expected = "\x00" * (self.bytesize - len(expected)) + expected
 276
 277             # Pack work?
 278             format = ">" + code
 279             got = pack(format, x)
 280             verify(got == expected,
 281                    "'%s'-pack of %r gave %r, not %r" %
 282                     (format, x, got, expected))
 283
 284             # Unpack work?
 285             retrieved = unpack(format, got)[0]
 286             verify(x == retrieved,
 287                    "'%s'-unpack of %r gave %r, not %r" %
 288                     (format, got, retrieved, x))
 289
 290             # Adding any byte should cause a "too big" error.
 291             any_err(unpack, format, '\x01' + got)
 292
 293             # Try little-endian.
 294             format = "<" + code
 295             expected = string_reverse(expected)
 296
 297             # Pack work?
 298             got = pack(format, x)
 299             verify(got == expected,
 300                    "'%s'-pack of %r gave %r, not %r" %
 301                     (format, x, got, expected))
 302
 303             # Unpack work?
 304             retrieved = unpack(format, got)[0]
 305             verify(x == retrieved,
 306                    "'%s'-unpack of %r gave %r, not %r" %
 307                     (format, got, retrieved, x))
 308
 309             # Adding any byte should cause a "too big" error.
 310             any_err(unpack, format, '\x01' + got)
 311
 312         else:
 313             # x is out of range -- verify pack realizes that.
 314             if not PY_STRUCT_RANGE_CHECKING and code in self.BUGGY_RANGE_CHECK:
 315                 if verbose:
 316                     print "Skipping buggy range check for code", code
 317             else:
 318                 deprecated_err(pack, ">" + code, x)
 319                 deprecated_err(pack, "<" + code, x)
 320
 321         # Much the same for unsigned.
 322         code = self.unsigned_code
 323         if self.unsigned_min <= x <= self.unsigned_max:
 324             # Try big-endian.
 325             format = ">" + code
 326             expected = long(x)
 327             expected = hex(expected)[2:-1] # chop "0x" and trailing 'L'
 328             if len(expected) & 1:
 329                 expected = "0" + expected
 330             expected = unhexlify(expected)
 331             expected = "\x00" * (self.bytesize - len(expected)) + expected
 332
 333             # Pack work?
 334             got = pack(format, x)
 335             verify(got == expected,
 336                    "'%s'-pack of %r gave %r, not %r" %
 337                     (format, x, got, expected))
 338
 339             # Unpack work?
 340             retrieved = unpack(format, got)[0]
 341             verify(x == retrieved,
 342                    "'%s'-unpack of %r gave %r, not %r" %
 343                     (format, got, retrieved, x))
 344
 345             # Adding any byte should cause a "too big" error.
 346             any_err(unpack, format, '\x01' + got)
 347
 348             # Try little-endian.
 349             format = "<" + code
 350             expected = string_reverse(expected)
 351
 352             # Pack work?
 353             got = pack(format, x)
 354             verify(got == expected,
 355                    "'%s'-pack of %r gave %r, not %r" %
 356                     (format, x, got, expected))
 357
 358             # Unpack work?
 359             retrieved = unpack(format, got)[0]
 360             verify(x == retrieved,
 361                    "'%s'-unpack of %r gave %r, not %r" %
 362                     (format, got, retrieved, x))
 363
 364             # Adding any byte should cause a "too big" error.
 365             any_err(unpack, format, '\x01' + got)
 366
 367         else:
 368             # x is out of range -- verify pack realizes that.
 369             if not PY_STRUCT_RANGE_CHECKING and code in self.BUGGY_RANGE_CHECK:
 370                 if verbose:
 371                     print "Skipping buggy range check for code", code
 372             else:
 373                 deprecated_err(pack, ">" + code, x)
 374                 deprecated_err(pack, "<" + code, x)
 375
 376     def run(self):
 377         from random import randrange
 378
 379         # Create all interesting powers of 2.
 380         values = []
 381         for exp in range(self.bitsize + 3):
 382             values.append(1L << exp)
 383
 384         # Add some random values.
 385         for i in range(self.bitsize):
 386             val = 0L
 387             for j in range(self.bytesize):
 388                 val = (val << 8) | randrange(256)
 389             values.append(val)
 390
 391         # Try all those, and their negations, and +-1 from them.  Note
 392         # that this tests all power-of-2 boundaries in range, and a few out
 393         # of range, plus +-(2**n +- 1).
 394         for base in values:
 395             for val in -base, base:
 396                 for incr in -1, 0, 1:
 397                     x = val + incr
 398                     try:
 399                         x = int(x)
 400                     except OverflowError:
 401                         pass
 402                     self.test_one(x)
 403
 404         # Some error cases.
 405         for direction in "<>":
 406             for code in self.formatpair:
 407                 for badobject in "a string", 3+42j, randrange:
 408                     any_err(struct.pack, direction + code, badobject)
 409
 410 for args in [("bB", 1),
 411              ("hH", 2),
 412              ("iI", 4),
 413              ("lL", 4),
 414              ("qQ", 8)]:
 415     t = IntTester(*args)
 416     t.run()
 417
 418
 419 ###########################################################################
 420 # The p ("Pascal string") code.
 421
 422 def test_p_code():
 423     for code, input, expected, expectedback in [
 424             ('p','abc', '\x00', ''),
 425             ('1p', 'abc', '\x00', ''),
 426             ('2p', 'abc', '\x01a', 'a'),
 427             ('3p', 'abc', '\x02ab', 'ab'),
 428             ('4p', 'abc', '\x03abc', 'abc'),
 429             ('5p', 'abc', '\x03abc\x00', 'abc'),
 430             ('6p', 'abc', '\x03abc\x00\x00', 'abc'),
 431             ('1000p', 'x'*1000, '\xff' + 'x'*999, 'x'*255)]:
 432         got = struct.pack(code, input)
 433         if got != expected:
 434             raise TestFailed("pack(%r, %r) == %r but expected %r" %
 435                              (code, input, got, expected))
 436         (got,) = struct.unpack(code, got)
 437         if got != expectedback:
 438             raise TestFailed("unpack(%r, %r) == %r but expected %r" %
 439                              (code, input, got, expectedback))
 440
 441 test_p_code()
 442
 443
 444 ###########################################################################
 445 # SF bug 705836.  "<f" and ">f" had a severe rounding bug, where a carry
 446 # from the low-order discarded bits could propagate into the exponent
 447 # field, causing the result to be wrong by a factor of 2.
 448
 449 def test_705836():
 450     import math
 451
 452     for base in range(1, 33):
 453         # smaller <- largest representable float less than base.
 454         delta = 0.5
 455         while base - delta / 2.0 != base:
 456             delta /= 2.0
 457         smaller = base - delta
 458         # Packing this rounds away a solid string of trailing 1 bits.
 459         packed = struct.pack("<f", smaller)
 460         unpacked = struct.unpack("<f", packed)[0]
 461         # This failed at base = 2, 4, and 32, with unpacked = 1, 2, and
 462         # 16, respectively.
 463         verify(base == unpacked)
 464         bigpacked = struct.pack(">f", smaller)
 465         verify(bigpacked == string_reverse(packed),
 466                ">f pack should be byte-reversal of <f pack")
 467         unpacked = struct.unpack(">f", bigpacked)[0]
 468         verify(base == unpacked)
 469
 470     # Largest finite IEEE single.
 471     big = (1 << 24) - 1
 472     big = math.ldexp(big, 127 - 23)
 473     packed = struct.pack(">f", big)
 474     unpacked = struct.unpack(">f", packed)[0]
 475     verify(big == unpacked)
 476
 477     # The same, but tack on a 1 bit so it rounds up to infinity.
 478     big = (1 << 25) - 1
 479     big = math.ldexp(big, 127 - 24)
 480     try:
 481         packed = struct.pack(">f", big)
 482     except OverflowError:
 483         pass
 484     else:
 485         TestFailed("expected OverflowError")
 486
 487 test_705836()
 488
 489 ###########################################################################
 490 # SF bug 1229380. No struct.pack exception for some out of range integers
 491
 492 def test_1229380():
 493     import sys
 494     for endian in ('', '>', '<'):
 495         for cls in (int, long):
 496             for fmt in ('B', 'H', 'I', 'L'):
 497                 deprecated_err(struct.pack, endian + fmt, cls(-1))
 498
 499             deprecated_err(struct.pack, endian + 'B', cls(300))
 500             deprecated_err(struct.pack, endian + 'H', cls(70000))
 501
 502         deprecated_err(struct.pack, endian + 'I', sys.maxint * 4L)
 503         deprecated_err(struct.pack, endian + 'L', sys.maxint * 4L)
 504
 505 if PY_STRUCT_RANGE_CHECKING:
 506     test_1229380()
 507
 508 ###########################################################################
 509 # SF bug 1530559. struct.pack raises TypeError where it used to convert.
 510
 511 def check_float_coerce(format, number):
 512     if PY_STRUCT_FLOAT_COERCE == 2:
 513         # Test for pre-2.5 struct module
 514         packed = struct.pack(format, number)
 515         floored = struct.unpack(format, packed)[0]
 516         if floored != int(number):
 517             raise TestFailed("did not correcly coerce float to int")
 518         return
 519     try:
 520         func(*args)
 521     except (struct.error, TypeError):
 522         if PY_STRUCT_FLOAT_COERCE:
 523             raise TestFailed("expected DeprecationWarning for float coerce")
 524     except DeprecationWarning:
 525         if not PY_STRUCT_FLOAT_COERCE:
 526             raise TestFailed("expected to raise struct.error for float coerce")
 527     else:
 528         raise TestFailed("did not raise error for float coerce")
 529
 530 check_float_coerce = with_warning_restore(deprecated_err)
 531
 532 def test_1530559():
 533     for endian in ('', '>', '<'):
 534         for fmt in ('B', 'H', 'I', 'L', 'b', 'h', 'i', 'l'):
 535             check_float_coerce(endian + fmt, 1.0)
 536             check_float_coerce(endian + fmt, 1.5)
 537
 538 test_1530559()
 539
 540 ###########################################################################
 541 # Packing and unpacking to/from buffers.
 542
 543 # Copied and modified from unittest.
 544 def assertRaises(excClass, callableObj, *args, **kwargs):
 545     try:
 546         callableObj(*args, **kwargs)
 547     except excClass:
 548         return
 549     else:
 550         raise TestFailed("%s not raised." % excClass)
 551
 552 def test_unpack_from():
 553     test_string = 'abcd01234'
 554     fmt = '4s'
 555     s = struct.Struct(fmt)
 556     for cls in (str, buffer):
 557         data = cls(test_string)
 558         vereq(s.unpack_from(data), ('abcd',))
 559         vereq(s.unpack_from(data, 2), ('cd01',))
 560         vereq(s.unpack_from(data, 4), ('0123',))
 561         for i in xrange(6):
 562             vereq(s.unpack_from(data, i), (data[i:i+4],))
 563         for i in xrange(6, len(test_string) + 1):
 564             simple_err(s.unpack_from, data, i)
 565     for cls in (str, buffer):
 566         data = cls(test_string)
 567         vereq(struct.unpack_from(fmt, data), ('abcd',))
 568         vereq(struct.unpack_from(fmt, data, 2), ('cd01',))
 569         vereq(struct.unpack_from(fmt, data, 4), ('0123',))
 570         for i in xrange(6):
 571             vereq(struct.unpack_from(fmt, data, i), (data[i:i+4],))
 572         for i in xrange(6, len(test_string) + 1):
 573             simple_err(struct.unpack_from, fmt, data, i)
 574
 575 def test_pack_into():
 576     test_string = 'Reykjavik rocks, eow!'
 577     writable_buf = array.array('c', ' '*100)
 578     fmt = '21s'
 579     s = struct.Struct(fmt)
 580
 581     # Test without offset
 582     s.pack_into(writable_buf, 0, test_string)
 583     from_buf = writable_buf.tostring()[:len(test_string)]
 584     vereq(from_buf, test_string)
 585
 586     # Test with offset.
 587     s.pack_into(writable_buf, 10, test_string)
 588     from_buf = writable_buf.tostring()[:len(test_string)+10]
 589     vereq(from_buf, test_string[:10] + test_string)
 590
 591     # Go beyond boundaries.
 592     small_buf = array.array('c', ' '*10)
 593     assertRaises(struct.error, s.pack_into, small_buf, 0, test_string)
 594     assertRaises(struct.error, s.pack_into, small_buf, 2, test_string)
 595
 596 def test_pack_into_fn():
 597     test_string = 'Reykjavik rocks, eow!'
 598     writable_buf = array.array('c', ' '*100)
 599     fmt = '21s'
 600     pack_into = lambda *args: struct.pack_into(fmt, *args)
 601
 602     # Test without offset.
 603     pack_into(writable_buf, 0, test_string)
 604     from_buf = writable_buf.tostring()[:len(test_string)]
 605     vereq(from_buf, test_string)
 606
 607     # Test with offset.
 608     pack_into(writable_buf, 10, test_string)
 609     from_buf = writable_buf.tostring()[:len(test_string)+10]
 610     vereq(from_buf, test_string[:10] + test_string)
 611
 612     # Go beyond boundaries.
 613     small_buf = array.array('c', ' '*10)
 614     assertRaises(struct.error, pack_into, small_buf, 0, test_string)
 615     assertRaises(struct.error, pack_into, small_buf, 2, test_string)
 616
 617 def test_unpack_with_buffer():
 618     # SF bug 1563759: struct.unpack doens't support buffer protocol objects
 619     data1 = array.array('B', '\x12\x34\x56\x78')
 620     data2 = buffer('......\x12\x34\x56\x78......', 6, 4)
 621     for data in [data1, data2]:
 622         value, = struct.unpack('>I', data)
 623         vereq(value, 0x12345678)
 624
 625 # Test methods to pack and unpack from buffers rather than strings.
 626 test_unpack_from()
 627 test_pack_into()
 628 test_pack_into_fn()
 629 test_unpack_with_buffer()
 630
 631 def test_bool():
 632     for prefix in tuple("<>!=")+('',):
 633         false = (), [], [], '', 0
 634         true = [1], 'test', 5, -1, 0xffffffffL+1, 0xffffffff/2
 635
 636         falseFormat = prefix + 't' * len(false)
 637         if verbose:
 638             print 'trying bool pack/unpack on', false, 'using format', falseFormat
 639         packedFalse = struct.pack(falseFormat, *false)
 640         unpackedFalse = struct.unpack(falseFormat, packedFalse)
 641
 642         trueFormat = prefix + 't' * len(true)
 643         if verbose:
 644             print 'trying bool pack/unpack on', true, 'using format', trueFormat
 645         packedTrue = struct.pack(trueFormat, *true)
 646         unpackedTrue = struct.unpack(trueFormat, packedTrue)
 647
 648         if len(true) != len(unpackedTrue):
 649             raise TestFailed('unpacked true array is not of same size as input')
 650         if len(false) != len(unpackedFalse):
 651             raise TestFailed('unpacked false array is not of same size as input')
 652
 653         for t in unpackedFalse:
 654             if t is not False:
 655                 raise TestFailed('%r did not unpack as False' % t)
 656         for t in unpackedTrue:
 657             if t is not True:
 658                 raise TestFailed('%r did not unpack as false' % t)
 659
 660         if prefix and verbose:
 661             print 'trying size of bool with format %r' % (prefix+'t')
 662         packed = struct.pack(prefix+'t', 1)
 663
 664         if len(packed) != struct.calcsize(prefix+'t'):
 665             raise TestFailed('packed length is not equal to calculated size')
 666
 667         if len(packed) != 1 and prefix:
 668             raise TestFailed('encoded bool is not one byte: %r' % packed)
 669         elif not prefix and verbose:
 670             print 'size of bool in native format is %i' % (len(packed))
 671
 672         for c in '\x01\x7f\xff\x0f\xf0':
 673             if struct.unpack('>t', c)[0] is not True:
 674                 raise TestFailed('%c did not unpack as True' % c)
 675
 676 test_bool()