Lib/test/test_mmap.py

   1 from test_support import verify, vereq, TESTFN
   2 import mmap
   3 import os, re
   4
   5 PAGESIZE = mmap.PAGESIZE
   6
   7 def test_both():
   8     "Test mmap module on Unix systems and Windows"
   9
  10     # Create a file to be mmap'ed.
  11     if os.path.exists(TESTFN):
  12         os.unlink(TESTFN)
  13     f = open(TESTFN, 'w+')
  14
  15     try:    # unlink TESTFN no matter what
  16         # Write 2 pages worth of data to the file
  17         f.write('\0'* PAGESIZE)
  18         f.write('foo')
  19         f.write('\0'* (PAGESIZE-3) )
  20         f.flush()
  21         m = mmap.mmap(f.fileno(), 2 * PAGESIZE)
  22         f.close()
  23
  24         # Simple sanity checks
  25
  26         print type(m)  # SF bug 128713:  segfaulted on Linux
  27         print '  Position of foo:', m.find('foo') / float(PAGESIZE), 'pages'
  28         vereq(m.find('foo'), PAGESIZE)
  29
  30         print '  Length of file:', len(m) / float(PAGESIZE), 'pages'
  31         vereq(len(m), 2*PAGESIZE)
  32
  33         print '  Contents of byte 0:', repr(m[0])
  34         vereq(m[0], '\0')
  35         print '  Contents of first 3 bytes:', repr(m[0:3])
  36         vereq(m[0:3], '\0\0\0')
  37
  38         # Modify the file's content
  39         print "\n  Modifying file's content..."
  40         m[0] = '3'
  41         m[PAGESIZE +3: PAGESIZE +3+3] = 'bar'
  42
  43         # Check that the modification worked
  44         print '  Contents of byte 0:', repr(m[0])
  45         vereq(m[0], '3')
  46         print '  Contents of first 3 bytes:', repr(m[0:3])
  47         vereq(m[0:3], '3\0\0')
  48         print '  Contents of second page:',  repr(m[PAGESIZE-1 : PAGESIZE + 7])
  49         vereq(m[PAGESIZE-1 : PAGESIZE + 7], '\0foobar\0')
  50
  51         m.flush()
  52
  53         # Test doing a regular expression match in an mmap'ed file
  54         match = re.search('[A-Za-z]+', m)
  55         if match is None:
  56             print '  ERROR: regex match on mmap failed!'
  57         else:
  58             start, end = match.span(0)
  59             length = end - start
  60
  61             print '  Regex match on mmap (page start, length of match):',
  62             print start / float(PAGESIZE), length
  63
  64             vereq(start, PAGESIZE)
  65             vereq(end, PAGESIZE + 6)
  66
  67         # test seeking around (try to overflow the seek implementation)
  68         m.seek(0,0)
  69         print '  Seek to zeroth byte'
  70         vereq(m.tell(), 0)
  71         m.seek(42,1)
  72         print '  Seek to 42nd byte'
  73         vereq(m.tell(), 42)
  74         m.seek(0,2)
  75         print '  Seek to last byte'
  76         vereq(m.tell(), len(m))
  77
  78         print '  Try to seek to negative position...'
  79         try:
  80             m.seek(-1)
  81         except ValueError:
  82             pass
  83         else:
  84             verify(0, 'expected a ValueError but did not get it')
  85
  86         print '  Try to seek beyond end of mmap...'
  87         try:
  88             m.seek(1,2)
  89         except ValueError:
  90             pass
  91         else:
  92             verify(0, 'expected a ValueError but did not get it')
  93
  94         print '  Try to seek to negative position...'
  95         try:
  96             m.seek(-len(m)-1,2)
  97         except ValueError:
  98             pass
  99         else:
 100             verify(0, 'expected a ValueError but did not get it')
 101
 102         # Try resizing map
 103         print '  Attempting resize()'
 104         try:
 105             m.resize( 512 )
 106         except SystemError:
 107             # resize() not supported
 108             # No messages are printed, since the output of this test suite
 109             # would then be different across platforms.
 110             pass
 111         else:
 112             # resize() is supported
 113             verify(len(m) == 512,
 114                     "len(m) is %d, but expecting 512" % (len(m),) )
 115             # Check that we can no longer seek beyond the new size.
 116             try:
 117                 m.seek(513,0)
 118             except ValueError:
 119                 pass
 120             else:
 121                 verify(0, 'Could seek beyond the new size')
 122
 123         m.close()
 124
 125     finally:
 126         try:
 127             f.close()
 128         except OSError:
 129             pass
 130         try:
 131             os.unlink(TESTFN)
 132         except OSError:
 133             pass
 134
 135     # Test for "access" keyword parameter
 136     try:
 137         mapsize = 10
 138         print "  Creating", mapsize, "byte test data file."
 139         open(TESTFN, "wb").write("a"*mapsize)
 140         print "  Opening mmap with access=ACCESS_READ"
 141         f = open(TESTFN, "rb")
 142         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_READ)
 143         verify(m[:] == 'a'*mapsize, "Readonly memory map data incorrect.")
 144
 145         print "  Ensuring that readonly mmap can't be slice assigned."
 146         try:
 147             m[:] = 'b'*mapsize
 148         except TypeError:
 149             pass
 150         else:
 151             verify(0, "Able to write to readonly memory map")
 152
 153         print "  Ensuring that readonly mmap can't be item assigned."
 154         try:
 155             m[0] = 'b'
 156         except TypeError:
 157             pass
 158         else:
 159             verify(0, "Able to write to readonly memory map")
 160
 161         print "  Ensuring that readonly mmap can't be write() to."
 162         try:
 163             m.seek(0,0)
 164             m.write('abc')
 165         except TypeError:
 166             pass
 167         else:
 168             verify(0, "Able to write to readonly memory map")
 169
 170         print "  Ensuring that readonly mmap can't be write_byte() to."
 171         try:
 172             m.seek(0,0)
 173             m.write_byte('d')
 174         except TypeError:
 175             pass
 176         else:
 177             verify(0, "Able to write to readonly memory map")
 178
 179         print "  Ensuring that readonly mmap can't be resized."
 180         try:
 181             m.resize(2*mapsize)
 182         except SystemError:   # resize is not universally supported
 183             pass
 184         except TypeError:
 185             pass
 186         else:
 187             verify(0, "Able to resize readonly memory map")
 188         del m, f
 189         verify(open(TESTFN, "rb").read() == 'a'*mapsize,
 190                "Readonly memory map data file was modified")
 191
 192         print "  Opening mmap with access=ACCESS_WRITE"
 193         f = open(TESTFN, "r+b")
 194         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_WRITE)
 195         print "  Modifying write-through memory map."
 196         m[:] = 'c'*mapsize
 197         verify(m[:] == 'c'*mapsize,
 198                "Write-through memory map memory not updated properly.")
 199         m.flush()
 200         del m, f
 201         verify(open(TESTFN).read() == 'c'*mapsize,
 202                "Write-through memory map data file not updated properly.")
 203
 204         print "  Opening mmap with access=ACCESS_COPY"
 205         f = open(TESTFN, "r+b")
 206         m = mmap.mmap(f.fileno(), mapsize, access=mmap.ACCESS_COPY)
 207         print "  Modifying copy-on-write memory map."
 208         m[:] = 'd'*mapsize
 209         verify(m[:] == 'd' * mapsize,
 210                "Copy-on-write memory map data not written correctly.")
 211         m.flush()
 212         verify(open(TESTFN, "rb").read() == 'c'*mapsize,
 213                "Copy-on-write test data file should not be modified.")
 214         try:
 215             print "  Ensuring copy-on-write maps cannot be resized."
 216             m.resize(2*mapsize)
 217         except TypeError:
 218             pass
 219         else:
 220             verify(0, "Copy-on-write mmap resize did not raise exception.")
 221         del m, f
 222         try:
 223             print "  Ensuring invalid access parameter raises exception."
 224             f = open(TESTFN, "r+b")
 225             m = mmap.mmap(f.fileno(), mapsize, access=4)
 226         except ValueError:
 227             pass
 228         else:
 229             verify(0, "Invalid access code should have raised exception.")
 230
 231         if os.name == "posix":
 232             # Try incompatible flags, prot and access parameters.
 233             f = open(TESTFN, "r+b")
 234             try:
 235                 m = mmap.mmap(f.fileno(), mapsize, flags=mmap.MAP_PRIVATE,
 236                               prot=mmap.PROT_READ, access=mmap.ACCESS_WRITE)
 237             except ValueError:
 238                 pass
 239             else:
 240                 verify(0, "Incompatible parameters should raise ValueError.")
 241             f.close()
 242     finally:
 243         try:
 244             os.unlink(TESTFN)
 245         except OSError:
 246             pass
 247
 248     # Do a tougher .find() test.  SF bug 515943 pointed out that, in 2.2,
 249     # searching for data with embedded \0 bytes didn't work.
 250     f = open(TESTFN, 'w+')
 251
 252     try:    # unlink TESTFN no matter what
 253         data = 'aabaac\x00deef\x00\x00aa\x00'
 254         n = len(data)
 255         f.write(data)
 256         f.flush()
 257         m = mmap.mmap(f.fileno(), n)
 258         f.close()
 259
 260         for start in range(n+1):
 261             for finish in range(start, n+1):
 262                 slice = data[start : finish]
 263                 vereq(m.find(slice), data.find(slice))
 264                 vereq(m.find(slice + 'x'), -1)
 265
 266     finally:
 267         try:
 268             os.unlink(TESTFN)
 269         except OSError:
 270             pass
 271
 272
 273
 274     print ' Test passed'
 275
 276 test_both()