diff -r 3dbf4c9b3ed4 Lib/test/test_mmap.py
--- a/Lib/test/test_mmap.py	Thu Jun 02 11:28:07 2011 +0200
+++ b/Lib/test/test_mmap.py	Thu Jun 02 11:56:40 2011 +0200
@@ -84,13 +84,13 @@
         self.assertEqual(m.tell(), len(m))
 
         # Try to seek to negative position...
-        self.assertRaises(ValueError, m.seek, -1)
+        self.assertRaises(IndexError, m.seek, -1)
 
         # Try to seek beyond end of mmap...
-        self.assertRaises(ValueError, m.seek, 1, 2)
+        self.assertRaises(IndexError, m.seek, 1, 2)
 
         # Try to seek to negative position...
-        self.assertRaises(ValueError, m.seek, -len(m)-1, 2)
+        self.assertRaises(IndexError, m.seek, -len(m)-1, 2)
 
         # Try resizing map
         try:
@@ -104,7 +104,7 @@
             # resize() is supported
             self.assertEqual(len(m), 512)
             # Check that we can no longer seek beyond the new size.
-            self.assertRaises(ValueError, m.seek, 513, 0)
+            self.assertRaises(IndexError, m.seek, 513, 0)
 
             # Check that the underlying file is truncated too
             # (bug #728515)
@@ -178,8 +178,8 @@
         with open(TESTFN, "r+b") as f:
             try:
                 m = mmap.mmap(f.fileno(), mapsize+1)
-            except ValueError:
-                # we do not expect a ValueError on Windows
+            except IndexError:
+                # we do not expect a IndexError on Windows
                 # CAUTION:  This also changes the size of the file on disk, and
                 # later tests assume that the length hasn't changed.  We need to
                 # repair that.
@@ -353,7 +353,7 @@
             f.write(115699 * b'm') # Arbitrary character
 
         with open(TESTFN, "w+b") as f:
-            self.assertRaises(ValueError, mmap.mmap, f.fileno(), 0,
+            self.assertRaises(IndexError, mmap.mmap, f.fileno(), 0,
                               offset=2147418112)
 
     def test_move(self):
@@ -387,20 +387,20 @@
         for source, dest, size in itertools.product(offsets, offsets, offsets):
             try:
                 m.move(source, dest, size)
-            except ValueError:
+            except IndexError:
                 pass
 
         offsets = [(-1, -1, -1), (-1, -1, 0), (-1, 0, -1), (0, -1, -1),
                    (-1, 0, 0), (0, -1, 0), (0, 0, -1)]
         for source, dest, size in offsets:
-            self.assertRaises(ValueError, m.move, source, dest, size)
+            self.assertRaises(IndexError, m.move, source, dest, size)
 
         m.close()
 
         m = mmap.mmap(-1, 1) # single byte
-        self.assertRaises(ValueError, m.move, 0, 0, 2)
-        self.assertRaises(ValueError, m.move, 1, 0, 1)
-        self.assertRaises(ValueError, m.move, 0, 1, 1)
+        self.assertRaises(IndexError, m.move, 0, 0, 2)
+        self.assertRaises(IndexError, m.move, 1, 0, 1)
+        self.assertRaises(IndexError, m.move, 0, 1, 1)
         m.move(0, 0, 1)
         m.move(0, 0, 0)
 
@@ -475,7 +475,7 @@
                 try:
                     m = mmap.mmap(f.fileno(), mapsize, offset=offset)
                     self.assertEqual(0, 1)
-                except (ValueError, TypeError, OverflowError):
+                except (IndexError, TypeError, OverflowError):
                     pass
                 else:
                     self.assertEqual(0, 0)
@@ -496,7 +496,7 @@
                 # resize() is supported
                 self.assertEqual(len(m), 512)
                 # Check that we can no longer seek beyond the new size.
-                self.assertRaises(ValueError, m.seek, 513, 0)
+                self.assertRaises(IndexError, m.seek, 513, 0)
                 # Check that the content is not changed
                 self.assertEqual(m[0:3], b'foo')
 
@@ -549,7 +549,7 @@
             self.assertEqual(m.tell(), i)
             m.write_byte(data[i])
             self.assertEqual(m.tell(), i+1)
-        self.assertRaises(ValueError, m.write_byte, b"x"[0])
+        self.assertRaises(IndexError, m.write_byte, b"x"[0])
         self.assertEqual(m[:], data)
         # Test read_byte()
         m.seek(0)
@@ -557,7 +557,7 @@
             self.assertEqual(m.tell(), i)
             self.assertEqual(m.read_byte(), data[i])
             self.assertEqual(m.tell(), i+1)
-        self.assertRaises(ValueError, m.read_byte)
+        self.assertRaises(IndexError, m.read_byte)
         # Test read()
         m.seek(3)
         self.assertEqual(m.read(3), b"345")
@@ -568,7 +568,7 @@
         self.assertEqual(m.tell(), 6)
         self.assertEqual(m[:], b"012bar6789")
         m.seek(8)
-        self.assertRaises(ValueError, m.write, b"bar")
+        self.assertRaises(IndexError, m.write, b"bar")
 
     def test_non_ascii_byte(self):
         for b in (129, 200, 255): # > 128
diff -r 3dbf4c9b3ed4 Modules/mmapmodule.c
--- a/Modules/mmapmodule.c	Thu Jun 02 11:28:07 2011 +0200
+++ b/Modules/mmapmodule.c	Thu Jun 02 11:56:40 2011 +0200
@@ -213,7 +213,7 @@
         self->pos += 1;
         return Py_BuildValue("B", (unsigned char)value);
     } else {
-        PyErr_SetString(PyExc_ValueError, "read byte out of range");
+        PyErr_SetString(PyExc_IndexError, "read byte out of range");
         return NULL;
     }
 }
@@ -372,7 +372,7 @@
         return NULL;
 
     if ((self->pos + length) > self->size) {
-        PyErr_SetString(PyExc_ValueError, "data out of range");
+        PyErr_SetString(PyExc_IndexError, "data out of range");
         return NULL;
     }
     memcpy(self->data+self->pos, data, length);
@@ -401,7 +401,7 @@
         return Py_None;
     }
     else {
-        PyErr_SetString(PyExc_ValueError, "write byte out of range");
+        PyErr_SetString(PyExc_IndexError, "write byte out of range");
         return NULL;
     }
 }
@@ -570,7 +570,7 @@
     if (!PyArg_ParseTuple(args, "|nn:flush", &offset, &size))
         return NULL;
     if ((size_t)(offset + size) > self->size) {
-        PyErr_SetString(PyExc_ValueError, "flush values out of range");
+        PyErr_SetString(PyExc_IndexError, "flush values out of range");
         return NULL;
     }
 
@@ -588,7 +588,7 @@
     }
     return PyLong_FromLong(0);
 #else
-    PyErr_SetString(PyExc_ValueError, "flush not supported on this system");
+    PyErr_SetString(PyExc_SystemError, "flush not supported on this system");
     return NULL;
 #endif
 }
@@ -631,7 +631,7 @@
     }
 
   onoutofrange:
-    PyErr_SetString(PyExc_ValueError, "seek out of range");
+    PyErr_SetString(PyExc_IndexError, "seek out of range");
     return NULL;
 }
 
@@ -648,7 +648,7 @@
         if (cnt < 0 || (cnt + dest) < cnt || (cnt + src) < cnt ||
            src < 0 || src > self->size || (src + cnt) > self->size ||
            dest < 0 || dest > self->size || (dest + cnt) > self->size) {
-            PyErr_SetString(PyExc_ValueError,
+            PyErr_SetString(PyExc_IndexError,
                 "source, destination, or count out of range");
             return NULL;
         }
@@ -757,8 +757,7 @@
         if (i < 0)
             i += self->size;
         if (i < 0 || (size_t)i >= self->size) {
-            PyErr_SetString(PyExc_IndexError,
-                "mmap index out of range");
+            PyErr_SetString(PyExc_IndexError, "mmap index out of range");
             return NULL;
         }
         return PyLong_FromLong(Py_CHARMASK(self->data[i]));
@@ -804,7 +803,7 @@
 mmap_concat(mmap_object *self, PyObject *bb)
 {
     CHECK_VALID(NULL);
-    PyErr_SetString(PyExc_SystemError,
+    PyErr_SetString(PyExc_ValueError,
                     "mmaps don't support concatenation");
     return NULL;
 }
@@ -813,7 +812,7 @@
 mmap_repeat(mmap_object *self, Py_ssize_t n)
 {
     CHECK_VALID(NULL);
-    PyErr_SetString(PyExc_SystemError,
+    PyErr_SetString(PyExc_ValueError,
                     "mmaps don't support repeat operation");
     return NULL;
 }
@@ -829,12 +828,12 @@
         return -1;
     }
     if (v == NULL) {
-        PyErr_SetString(PyExc_TypeError,
+        PyErr_SetString(PyExc_ValueError,
                         "mmap object doesn't support item deletion");
         return -1;
     }
     if (! (PyBytes_Check(v) && PyBytes_Size(v)==1) ) {
-        PyErr_SetString(PyExc_IndexError,
+        PyErr_SetString(PyExc_TypeError,
                         "mmap assignment must be length-1 bytes()");
         return -1;
     }
@@ -862,27 +861,23 @@
         if (i < 0)
             i += self->size;
         if (i < 0 || (size_t)i >= self->size) {
-            PyErr_SetString(PyExc_IndexError,
-                            "mmap index out of range");
+            PyErr_SetString(PyExc_IndexError, "mmap index out of range");
             return -1;
         }
         if (value == NULL) {
-            PyErr_SetString(PyExc_TypeError,
-                            "mmap doesn't support item deletion");
+            PyErr_SetString(PyExc_ValueError, "mmap doesn't support item deletion");
             return -1;
         }
         if (!PyIndex_Check(value)) {
-            PyErr_SetString(PyExc_TypeError,
-                            "mmap item value must be an int");
+            PyErr_SetString(PyExc_TypeError, "mmap item value must be an int");
             return -1;
         }
         v = PyNumber_AsSsize_t(value, PyExc_TypeError);
         if (v == -1 && PyErr_Occurred())
             return -1;
         if (v < 0 || v > 255) {
-            PyErr_SetString(PyExc_ValueError,
-                            "mmap item value must be "
-                            "in range(0, 256)");
+            PyErr_SetString(PyExc_ValueError, "mmap item value must be "
+                                              "in range(0, 256)");
             return -1;
         }
         self->data[i] = (char) v;
@@ -898,14 +893,14 @@
             return -1;
         }
         if (value == NULL) {
-            PyErr_SetString(PyExc_TypeError,
+            PyErr_SetString(PyExc_ValueError,
                 "mmap object doesn't support slice deletion");
             return -1;
         }
         if (PyObject_GetBuffer(value, &vbuf, PyBUF_SIMPLE) < 0)
             return -1;
         if (vbuf.len != slicelen) {
-            PyErr_SetString(PyExc_IndexError,
+            PyErr_SetString(PyExc_ValueError,
                 "mmap slice assignment is wrong size");
             PyBuffer_Release(&vbuf);
             return -1;
@@ -930,8 +925,7 @@
         return 0;
     }
     else {
-        PyErr_SetString(PyExc_TypeError,
-                        "mmap indices must be integer");
+        PyErr_SetString(PyExc_TypeError, "mmap indices must be integer");
         return -1;
     }
 }
@@ -1086,7 +1080,7 @@
     if (map_size < 0)
         return NULL;
     if (offset < 0) {
-        PyErr_SetString(PyExc_OverflowError,
+        PyErr_SetString(PyExc_IndexError,
             "memory mapped offset must be positive");
         return NULL;
     }
@@ -1141,19 +1135,19 @@
     if (fd != -1 && fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
         if (map_size == 0) {
             if (offset >= st.st_size) {
-                PyErr_SetString(PyExc_ValueError,
+                PyErr_SetString(PyExc_IndexError,
                                 "mmap offset is greater than file size");
                 return NULL;
             }
             off_t calc_size = st.st_size - offset;
             map_size = calc_size;
             if (map_size != calc_size) {
-                PyErr_SetString(PyExc_ValueError,
+                PyErr_SetString(PyExc_IndexError,
                                  "mmap length is too large");
                  return NULL;
              }
         } else if (offset + (size_t)map_size > st.st_size) {
-            PyErr_SetString(PyExc_ValueError,
+            PyErr_SetString(PyExc_IndexError,
                             "mmap length is greater than file size");
             return NULL;
         }
@@ -1337,7 +1331,7 @@
 
             size = (((PY_LONG_LONG) high) << 32) + low;
             if (offset >= size) {
-                PyErr_SetString(PyExc_ValueError,
+                PyErr_SetString(PyExc_IndexError,
                                 "mmap offset is greater than file size");
                 Py_DECREF(m_obj);
                 return NULL;