AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_mmap.py

   1 from test.test_support import (TESTFN, run_unittest, import_module, unlink,
   2                                requires, _2G, _4G)
   3 import unittest
   4 import os, re, itertools, socket, sys
   5
   6 mmap = import_module('mmap')
   7
   8 PAGESIZE = mmap.PAGESIZE
   9
  10 class MmapTests(unittest.TestCase):
  11
  12     def setUp(self):
  13         if os.path.exists(TESTFN):
  14             os.unlink(TESTFN)
  15
  16     def tearDown(self):
  17         try:
  18             os.unlink(TESTFN)
  19         except OSError:
  20             pass
  21
  22     def test_basic(self):
  23         # Test mmap module on Unix systems and Windows
  24
  25         # Create a file to be mmap'ed.
  26         f = open(TESTFN, 'w+')
  27         try:
  28             # Write 2 pages worth of data to the file
  29             f.write('\0'* PAGESIZE)
  30             f.write('foo')
  31             f.write('\0'* (PAGESIZE-3) )
  32             f.flush()
  33             m = mmap.mmap(f.fileno(), 2 * PAGESIZE)
  34             f.close()
  35
  36             # Simple sanity checks
  37
  38             tp = str(type(m))  # SF bug 128713:  segfaulted on Linux
  39             self.assertEqual(m.find('foo'), PAGESIZE)
  40
  41             self.assertEqual(len(m), 2*PAGESIZE)
  42
  43             self.assertEqual(m[0], '\0')
  44             self.assertEqual(m[0:3], '\0\0\0')
  45
  46             # Shouldn't crash on boundary (Issue #5292)
  47             self.assertRaises(IndexError, m.__getitem__, len(m))
  48             self.assertRaises(IndexError, m.__setitem__, len(m), '\0')
  49
  50             # Modify the file's content
  51             m[0] = '3'
  52             m[PAGESIZE +3: PAGESIZE +3+3] = 'bar'
  53
  54             # Check that the modification worked
  55             self.assertEqual(m[0], '3')
  56             self.assertEqual(m[0:3], '3\0\0')
  57             self.assertEqual(m[PAGESIZE-1 : PAGESIZE + 7], '\0foobar\0')
  58
  59             m.flush()
  60
  61             # Test doing a regular expression match in an mmap'ed file
  62             match = re.search('[A-Za-z]+', m)
  63             if match is None:
  64                 self.fail('regex match on mmap failed!')
  65             else:
  66                 start, end = match.span(0)
  67                 length = end - start
  68
  69                 self.assertEqual(start, PAGESIZE)
  70                 self.assertEqual(end, PAGESIZE + 6)
  71
  72             # test seeking around (try to overflow the seek implementation)
  73             m.seek(0,0)
  74             self.assertEqual(m.tell(), 0)
  75             m.seek(42,1)
  76             self.assertEqual(m.tell(), 42)
  77             m.seek(0,2)
  78             self.assertEqual(m.tell(), len(m))
  79
  80             # Try to seek to negative position...
  81             self.assertRaises(ValueError, m.seek, -1)
  82
  83             # Try to seek beyond end of mmap...
  84             self.assertRaises(ValueError, m.seek, 1, 2)
  85
  86             # Try to seek to negative position...
  87             self.assertRaises(ValueError, m.seek, -len(m)-1, 2)
  88
  89             # Try resizing map
  90             try:
  91                 m.resize(512)
  92             except SystemError:
  93                 # resize() not supported
  94                 # No messages are printed, since the output of this test suite
  95                 # would then be different across platforms.
  96                 pass
  97             else:
  98                 # resize() is supported
  99                 self.assertEqual(len(m), 512)
 100                 # Check that we can no longer seek beyond the new size.
 101                 self.assertRaises(ValueError, m.seek, 513, 0)
 102
 103                 # Check that the underlying file is truncated too
 104                 # (bug #728515)
 105                 f = open(TESTFN)
 106                 f.seek(0, 2)
 107                 self.assertEqual(f.tell(), 512)
 108                 f.close()
 109                 self.assertEqual(m.size(), 512)
 110
 111             m.close()
 112
 113         finally:
 114             try:
 115                 f.close()
 116             except OSError:
 117                 pass
 118
 119     def test_access_parameter(self):
 120         # Test for "access" keyword parameter
 121         mapsize = 10
 122         open(TESTFN, "wb").write("a"*mapsize)
 123         f = open(TESTFN, "rb")
 124         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_READ)
 125         self.assertEqual(m[:], 'a'*mapsize, "Readonly memory map data incorrect.")
 126
 127         # Ensuring that readonly mmap can't be slice assigned
 128         try:
 129             m[:] = 'b'*mapsize
 130         except TypeError:
 131             pass
 132         else:
 133             self.fail("Able to write to readonly memory map")
 134
 135         # Ensuring that readonly mmap can't be item assigned
 136         try:
 137             m[0] = 'b'
 138         except TypeError:
 139             pass
 140         else:
 141             self.fail("Able to write to readonly memory map")
 142
 143         # Ensuring that readonly mmap can't be write() to
 144         try:
 145             m.seek(0,0)
 146             m.write('abc')
 147         except TypeError:
 148             pass
 149         else:
 150             self.fail("Able to write to readonly memory map")
 151
 152         # Ensuring that readonly mmap can't be write_byte() to
 153         try:
 154             m.seek(0,0)
 155             m.write_byte('d')
 156         except TypeError:
 157             pass
 158         else:
 159             self.fail("Able to write to readonly memory map")
 160
 161         # Ensuring that readonly mmap can't be resized
 162         try:
 163             m.resize(2*mapsize)
 164         except SystemError:   # resize is not universally supported
 165             pass
 166         except TypeError:
 167             pass
 168         else:
 169             self.fail("Able to resize readonly memory map")
 170         f.close()
 171         del m, f
 172         self.assertEqual(open(TESTFN, "rb").read(), 'a'*mapsize,
 173                "Readonly memory map data file was modified")
 174
 175         # Opening mmap with size too big
 176         import sys
 177         f = open(TESTFN, "r+b")
 178         try:
 179             m = mmap.mmap(f.fileno(), mapsize+1)
 180         except ValueError:
 181             # we do not expect a ValueError on Windows
 182             # CAUTION:  This also changes the size of the file on disk, and
 183             # later tests assume that the length hasn't changed.  We need to
 184             # repair that.
 185             if sys.platform.startswith('win'):
 186                 self.fail("Opening mmap with size+1 should work on Windows.")
 187         else:
 188             # we expect a ValueError on Unix, but not on Windows
 189             if not sys.platform.startswith('win'):
 190                 self.fail("Opening mmap with size+1 should raise ValueError.")
 191             m.close()
 192         f.close()
 193         if sys.platform.startswith('win'):
 194             # Repair damage from the resizing test.
 195             f = open(TESTFN, 'r+b')
 196             f.truncate(mapsize)
 197             f.close()
 198
 199         # Opening mmap with access=ACCESS_WRITE
 200         f = open(TESTFN, "r+b")
 201         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_WRITE)
 202         # Modifying write-through memory map
 203         m[:] = 'c'*mapsize
 204         self.assertEqual(m[:], 'c'*mapsize,
 205                "Write-through memory map memory not updated properly.")
 206         m.flush()
 207         m.close()
 208         f.close()
 209         f = open(TESTFN, 'rb')
 210         stuff = f.read()
 211         f.close()
 212         self.assertEqual(stuff, 'c'*mapsize,
 213                "Write-through memory map data file not updated properly.")
 214
 215         # Opening mmap with access=ACCESS_COPY
 216         f = open(TESTFN, "r+b")
 217         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_COPY)
 218         # Modifying copy-on-write memory map
 219         m[:] = 'd'*mapsize
 220         self.assertEqual(m[:], 'd' * mapsize,
 221                "Copy-on-write memory map data not written correctly.")
 222         m.flush()
 223         self.assertEqual(open(TESTFN, "rb").read(), 'c'*mapsize,
 224                "Copy-on-write test data file should not be modified.")
 225         # Ensuring copy-on-write maps cannot be resized
 226         self.assertRaises(TypeError, m.resize, 2*mapsize)
 227         f.close()
 228         del m, f
 229
 230         # Ensuring invalid access parameter raises exception
 231         f = open(TESTFN, "r+b")
 232         self.assertRaises(ValueError, mmap.mmap, f.fileno(), mapsize, access=4)
 233         f.close()
 234
 235         if os.name == "posix":
 236             # Try incompatible flags, prot and access parameters.
 237             f = open(TESTFN, "r+b")
 238             self.assertRaises(ValueError, mmap.mmap, f.fileno(), mapsize,
 239                               flags=mmap.MAP_PRIVATE,
 240                               prot=mmap.PROT_READ, access=mmap.ACCESS_WRITE)
 241             f.close()
 242
 243             # Try writing with PROT_EXEC and without PROT_WRITE
 244             prot = mmap.PROT_READ | getattr(mmap, 'PROT_EXEC', 0)
 245             with open(TESTFN, "r+b") as f:
 246                 m = mmap.mmap(f.fileno(), mapsize, prot=prot)
 247                 self.assertRaises(TypeError, m.write, b"abcdef")
 248                 self.assertRaises(TypeError, m.write_byte, 0)
 249                 m.close()
 250
 251     def test_bad_file_desc(self):
 252         # Try opening a bad file descriptor...
 253         self.assertRaises(mmap.error, mmap.mmap, -2, 4096)
 254
 255     def test_tougher_find(self):
 256         # Do a tougher .find() test.  SF bug 515943 pointed out that, in 2.2,
 257         # searching for data with embedded \0 bytes didn't work.
 258         f = open(TESTFN, 'w+')
 259
 260         data = 'aabaac\x00deef\x00\x00aa\x00'
 261         n = len(data)
 262         f.write(data)
 263         f.flush()
 264         m = mmap.mmap(f.fileno(), n)
 265         f.close()
 266
 267         for start in range(n+1):
 268             for finish in range(start, n+1):
 269                 slice = data[start : finish]
 270                 self.assertEqual(m.find(slice), data.find(slice))
 271                 self.assertEqual(m.find(slice + 'x'), -1)
 272         m.close()
 273
 274     def test_find_end(self):
 275         # test the new 'end' parameter works as expected
 276         f = open(TESTFN, 'w+')
 277         data = 'one two ones'
 278         n = len(data)
 279         f.write(data)
 280         f.flush()
 281         m = mmap.mmap(f.fileno(), n)
 282         f.close()
 283
 284         self.assertEqual(m.find('one'), 0)
 285         self.assertEqual(m.find('ones'), 8)
 286         self.assertEqual(m.find('one', 0, -1), 0)
 287         self.assertEqual(m.find('one', 1), 8)
 288         self.assertEqual(m.find('one', 1, -1), 8)
 289         self.assertEqual(m.find('one', 1, -2), -1)
 290
 291
 292     def test_rfind(self):
 293         # test the new 'end' parameter works as expected
 294         f = open(TESTFN, 'w+')
 295         data = 'one two ones'
 296         n = len(data)
 297         f.write(data)
 298         f.flush()
 299         m = mmap.mmap(f.fileno(), n)
 300         f.close()
 301
 302         self.assertEqual(m.rfind('one'), 8)
 303         self.assertEqual(m.rfind('one '), 0)
 304         self.assertEqual(m.rfind('one', 0, -1), 8)
 305         self.assertEqual(m.rfind('one', 0, -2), 0)
 306         self.assertEqual(m.rfind('one', 1, -1), 8)
 307         self.assertEqual(m.rfind('one', 1, -2), -1)
 308
 309
 310     def test_double_close(self):
 311         # make sure a double close doesn't crash on Solaris (Bug# 665913)
 312         f = open(TESTFN, 'w+')
 313
 314         f.write(2**16 * 'a') # Arbitrary character
 315         f.close()
 316
 317         f = open(TESTFN)
 318         mf = mmap.mmap(f.fileno(), 2**16, access=mmap.ACCESS_READ)
 319         mf.close()
 320         mf.close()
 321         f.close()
 322
 323     def test_entire_file(self):
 324         # test mapping of entire file by passing 0 for map length
 325         if hasattr(os, "stat"):
 326             f = open(TESTFN, "w+")
 327
 328             f.write(2**16 * 'm') # Arbitrary character
 329             f.close()
 330
 331             f = open(TESTFN, "rb+")
 332             mf = mmap.mmap(f.fileno(), 0)
 333             self.assertEqual(len(mf), 2**16, "Map size should equal file size.")
 334             self.assertEqual(mf.read(2**16), 2**16 * "m")
 335             mf.close()
 336             f.close()
 337
 338     def test_length_0_offset(self):
 339         # Issue #10916: test mapping of remainder of file by passing 0 for
 340         # map length with an offset doesn't cause a segfault.
 341         if not hasattr(os, "stat"):
 342             self.skipTest("needs os.stat")
 343         # NOTE: allocation granularity is currently 65536 under Win64,
 344         # and therefore the minimum offset alignment.
 345         with open(TESTFN, "wb") as f:
 346             f.write((65536 * 2) * b'm') # Arbitrary character
 347
 348         with open(TESTFN, "rb") as f:
 349             mf = mmap.mmap(f.fileno(), 0, offset=65536, access=mmap.ACCESS_READ)
 350             try:
 351                 self.assertRaises(IndexError, mf.__getitem__, 80000)
 352             finally:
 353                 mf.close()
 354
 355     def test_length_0_large_offset(self):
 356         # Issue #10959: test mapping of a file by passing 0 for
 357         # map length with a large offset doesn't cause a segfault.
 358         if not hasattr(os, "stat"):
 359             self.skipTest("needs os.stat")
 360
 361         with open(TESTFN, "wb") as f:
 362             f.write(115699 * b'm') # Arbitrary character
 363
 364         with open(TESTFN, "w+b") as f:
 365             self.assertRaises(ValueError, mmap.mmap, f.fileno(), 0,
 366                               offset=2147418112)
 367
 368     def test_move(self):
 369         # make move works everywhere (64-bit format problem earlier)
 370         f = open(TESTFN, 'w+')
 371
 372         f.write("ABCDEabcde") # Arbitrary character
 373         f.flush()
 374
 375         mf = mmap.mmap(f.fileno(), 10)
 376         mf.move(5, 0, 5)
 377         self.assertEqual(mf[:], "ABCDEABCDE", "Map move should have duplicated front 5")
 378         mf.close()
 379         f.close()
 380
 381         # more excessive test
 382         data = "0123456789"
 383         for dest in range(len(data)):
 384             for src in range(len(data)):
 385                 for count in range(len(data) - max(dest, src)):
 386                     expected = data[:dest] + data[src:src+count] + data[dest+count:]
 387                     m = mmap.mmap(-1, len(data))
 388                     m[:] = data
 389                     m.move(dest, src, count)
 390                     self.assertEqual(m[:], expected)
 391                     m.close()
 392
 393         # segfault test (Issue 5387)
 394         m = mmap.mmap(-1, 100)
 395         offsets = [-100, -1, 0, 1, 100]
 396         for source, dest, size in itertools.product(offsets, offsets, offsets):
 397             try:
 398                 m.move(source, dest, size)
 399             except ValueError:
 400                 pass
 401
 402         offsets = [(-1, -1, -1), (-1, -1, 0), (-1, 0, -1), (0, -1, -1),
 403                    (-1, 0, 0), (0, -1, 0), (0, 0, -1)]
 404         for source, dest, size in offsets:
 405             self.assertRaises(ValueError, m.move, source, dest, size)
 406
 407         m.close()
 408
 409         m = mmap.mmap(-1, 1) # single byte
 410         self.assertRaises(ValueError, m.move, 0, 0, 2)
 411         self.assertRaises(ValueError, m.move, 1, 0, 1)
 412         self.assertRaises(ValueError, m.move, 0, 1, 1)
 413         m.move(0, 0, 1)
 414         m.move(0, 0, 0)
 415
 416
 417     def test_anonymous(self):
 418         # anonymous mmap.mmap(-1, PAGE)
 419         m = mmap.mmap(-1, PAGESIZE)
 420         for x in xrange(PAGESIZE):
 421             self.assertEqual(m[x], '\0', "anonymously mmap'ed contents should be zero")
 422
 423         for x in xrange(PAGESIZE):
 424             m[x] = ch = chr(x & 255)
 425             self.assertEqual(m[x], ch)
 426
 427     def test_extended_getslice(self):
 428         # Test extended slicing by comparing with list slicing.
 429         s = "".join(chr(c) for c in reversed(range(256)))
 430         m = mmap.mmap(-1, len(s))
 431         m[:] = s
 432         self.assertEqual(m[:], s)
 433         indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
 434         for start in indices:
 435             for stop in indices:
 436                 # Skip step 0 (invalid)
 437                 for step in indices[1:]:
 438                     self.assertEqual(m[start:stop:step],
 439                                      s[start:stop:step])
 440
 441     def test_extended_set_del_slice(self):
 442         # Test extended slicing by comparing with list slicing.
 443         s = "".join(chr(c) for c in reversed(range(256)))
 444         m = mmap.mmap(-1, len(s))
 445         indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
 446         for start in indices:
 447             for stop in indices:
 448                 # Skip invalid step 0
 449                 for step in indices[1:]:
 450                     m[:] = s
 451                     self.assertEqual(m[:], s)
 452                     L = list(s)
 453                     # Make sure we have a slice of exactly the right length,
 454                     # but with different data.
 455                     data = L[start:stop:step]
 456                     data = "".join(reversed(data))
 457                     L[start:stop:step] = data
 458                     m[start:stop:step] = data
 459                     self.assertEqual(m[:], "".join(L))
 460
 461     def make_mmap_file (self, f, halfsize):
 462         # Write 2 pages worth of data to the file
 463         f.write ('\0' * halfsize)
 464         f.write ('foo')
 465         f.write ('\0' * (halfsize - 3))
 466         f.flush ()
 467         return mmap.mmap (f.fileno(), 0)
 468
 469     def test_offset (self):
 470         f = open (TESTFN, 'w+b')
 471
 472         try: # unlink TESTFN no matter what
 473             halfsize = mmap.ALLOCATIONGRANULARITY
 474             m = self.make_mmap_file (f, halfsize)
 475             m.close ()
 476             f.close ()
 477
 478             mapsize = halfsize * 2
 479             # Try invalid offset
 480             f = open(TESTFN, "r+b")
 481             for offset in [-2, -1, None]:
 482                 try:
 483                     m = mmap.mmap(f.fileno(), mapsize, offset=offset)
 484                     self.assertEqual(0, 1)
 485                 except (ValueError, TypeError, OverflowError):
 486                     pass
 487                 else:
 488                     self.assertEqual(0, 0)
 489             f.close()
 490
 491             # Try valid offset, hopefully 8192 works on all OSes
 492             f = open(TESTFN, "r+b")
 493             m = mmap.mmap(f.fileno(), mapsize - halfsize, offset=halfsize)
 494             self.assertEqual(m[0:3], 'foo')
 495             f.close()
 496
 497             # Try resizing map
 498             try:
 499                 m.resize(512)
 500             except SystemError:
 501                 pass
 502             else:
 503                 # resize() is supported
 504                 self.assertEqual(len(m), 512)
 505                 # Check that we can no longer seek beyond the new size.
 506                 self.assertRaises(ValueError, m.seek, 513, 0)
 507                 # Check that the content is not changed
 508                 self.assertEqual(m[0:3], 'foo')
 509
 510                 # Check that the underlying file is truncated too
 511                 f = open(TESTFN)
 512                 f.seek(0, 2)
 513                 self.assertEqual(f.tell(), halfsize + 512)
 514                 f.close()
 515                 self.assertEqual(m.size(), halfsize + 512)
 516
 517             m.close()
 518
 519         finally:
 520             f.close()
 521             try:
 522                 os.unlink(TESTFN)
 523             except OSError:
 524                 pass
 525
 526     def test_subclass(self):
 527         class anon_mmap(mmap.mmap):
 528             def __new__(klass, *args, **kwargs):
 529                 return mmap.mmap.__new__(klass, -1, *args, **kwargs)
 530         anon_mmap(PAGESIZE)
 531
 532     def test_prot_readonly(self):
 533         if not hasattr(mmap, 'PROT_READ'):
 534             return
 535         mapsize = 10
 536         open(TESTFN, "wb").write("a"*mapsize)
 537         f = open(TESTFN, "rb")
 538         m = mmap.mmap(f.fileno(), mapsize, prot=mmap.PROT_READ)
 539         self.assertRaises(TypeError, m.write, "foo")
 540         f.close()
 541
 542     def test_error(self):
 543         self.assertTrue(issubclass(mmap.error, EnvironmentError))
 544         self.assertIn("mmap.error", str(mmap.error))
 545
 546     def test_io_methods(self):
 547         data = "0123456789"
 548         open(TESTFN, "wb").write("x"*len(data))
 549         f = open(TESTFN, "r+b")
 550         m = mmap.mmap(f.fileno(), len(data))
 551         f.close()
 552         # Test write_byte()
 553         for i in xrange(len(data)):
 554             self.assertEqual(m.tell(), i)
 555             m.write_byte(data[i])
 556             self.assertEqual(m.tell(), i+1)
 557         self.assertRaises(ValueError, m.write_byte, "x")
 558         self.assertEqual(m[:], data)
 559         # Test read_byte()
 560         m.seek(0)
 561         for i in xrange(len(data)):
 562             self.assertEqual(m.tell(), i)
 563             self.assertEqual(m.read_byte(), data[i])
 564             self.assertEqual(m.tell(), i+1)
 565         self.assertRaises(ValueError, m.read_byte)
 566         # Test read()
 567         m.seek(3)
 568         self.assertEqual(m.read(3), "345")
 569         self.assertEqual(m.tell(), 6)
 570         # Test write()
 571         m.seek(3)
 572         m.write("bar")
 573         self.assertEqual(m.tell(), 6)
 574         self.assertEqual(m[:], "012bar6789")
 575         m.seek(8)
 576         self.assertRaises(ValueError, m.write, "bar")
 577
 578     if os.name == 'nt':
 579         def test_tagname(self):
 580             data1 = "0123456789"
 581             data2 = "abcdefghij"
 582             assert len(data1) == len(data2)
 583
 584             # Test same tag
 585             m1 = mmap.mmap(-1, len(data1), tagname="foo")
 586             m1[:] = data1
 587             m2 = mmap.mmap(-1, len(data2), tagname="foo")
 588             m2[:] = data2
 589             self.assertEqual(m1[:], data2)
 590             self.assertEqual(m2[:], data2)
 591             m2.close()
 592             m1.close()
 593
 594             # Test different tag
 595             m1 = mmap.mmap(-1, len(data1), tagname="foo")
 596             m1[:] = data1
 597             m2 = mmap.mmap(-1, len(data2), tagname="boo")
 598             m2[:] = data2
 599             self.assertEqual(m1[:], data1)
 600             self.assertEqual(m2[:], data2)
 601             m2.close()
 602             m1.close()
 603
 604         def test_crasher_on_windows(self):
 605             # Should not crash (Issue 1733986)
 606             m = mmap.mmap(-1, 1000, tagname="foo")
 607             try:
 608                 mmap.mmap(-1, 5000, tagname="foo")[:] # same tagname, but larger size
 609             except:
 610                 pass
 611             m.close()
 612
 613             # Should not crash (Issue 5385)
 614             open(TESTFN, "wb").write("x"*10)
 615             f = open(TESTFN, "r+b")
 616             m = mmap.mmap(f.fileno(), 0)
 617             f.close()
 618             try:
 619                 m.resize(0) # will raise WindowsError
 620             except:
 621                 pass
 622             try:
 623                 m[:]
 624             except:
 625                 pass
 626             m.close()
 627
 628         def test_invalid_descriptor(self):
 629             # socket file descriptors are valid, but out of range
 630             # for _get_osfhandle, causing a crash when validating the
 631             # parameters to _get_osfhandle.
 632             s = socket.socket()
 633             try:
 634                 with self.assertRaises(mmap.error):
 635                     m = mmap.mmap(s.fileno(), 10)
 636             finally:
 637                 s.close()
 638
 639
 640 class LargeMmapTests(unittest.TestCase):
 641
 642     def setUp(self):
 643         unlink(TESTFN)
 644
 645     def tearDown(self):
 646         unlink(TESTFN)
 647
 648     def _make_test_file(self, num_zeroes, tail):
 649         if sys.platform[:3] == 'win' or sys.platform == 'darwin':
 650             requires('largefile',
 651                 'test requires %s bytes and a long time to run' % str(0x180000000))
 652         f = open(TESTFN, 'w+b')
 653         try:
 654             f.seek(num_zeroes)
 655             f.write(tail)
 656             f.flush()
 657         except (IOError, OverflowError):
 658             f.close()
 659             raise unittest.SkipTest("filesystem does not have largefile support")
 660         return f
 661
 662     def test_large_offset(self):
 663         with self._make_test_file(0x14FFFFFFF, b" ") as f:
 664             m = mmap.mmap(f.fileno(), 0, offset=0x140000000, access=mmap.ACCESS_READ)
 665             try:
 666                 self.assertEqual(m[0xFFFFFFF], b" ")
 667             finally:
 668                 m.close()
 669
 670     def test_large_filesize(self):
 671         with self._make_test_file(0x17FFFFFFF, b" ") as f:
 672             m = mmap.mmap(f.fileno(), 0x10000, access=mmap.ACCESS_READ)
 673             try:
 674                 self.assertEqual(m.size(), 0x180000000)
 675             finally:
 676                 m.close()
 677
 678     # Issue 11277: mmap() with large (~4GB) sparse files crashes on OS X.
 679
 680     def _test_around_boundary(self, boundary):
 681         tail = b'  DEARdear  '
 682         start = boundary - len(tail) // 2
 683         end = start + len(tail)
 684         with self._make_test_file(start, tail) as f:
 685             m = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
 686             try:
 687                 self.assertEqual(m[start:end], tail)
 688             finally:
 689                 m.close()
 690
 691     @unittest.skipUnless(sys.maxsize > _4G, "test cannot run on 32-bit systems")
 692     def test_around_2GB(self):
 693         self._test_around_boundary(_2G)
 694
 695     @unittest.skipUnless(sys.maxsize > _4G, "test cannot run on 32-bit systems")
 696     def test_around_4GB(self):
 697         self._test_around_boundary(_4G)
 698
 699
 700 def test_main():
 701     run_unittest(MmapTests, LargeMmapTests)
 702
 703 if __name__ == '__main__':
 704     test_main()