diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 0fc017f..af5b6f4 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -260,7 +260,7 @@
 
     def test_array_writes(self):
         a = array.array('i', range(10))
-        n = len(memoryview(a))
+        n = len(a.tostring())
         f = io.open(support.TESTFN, "wb", 0)
         self.assertEqual(f.write(a), n)
         f.close()
diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py
index 7139065..cc8502b 100644
--- a/Lib/test/test_memoryview.py
+++ b/Lib/test/test_memoryview.py
@@ -8,24 +8,30 @@
 import sys
 import gc
 import weakref
+import array
 
 
-class CommonMemoryTests:
-    #
-    # Tests common to direct memoryviews and sliced memoryviews
-    #
+class AbstractMemoryTests:
+    source_bytes = b"abcdef"
 
-    base_object = b"abcdef"
+    @property
+    def _source(self):
+        return self.source_bytes
+
+    @property
+    def _types(self):
+        return filter(None, [self.ro_type, self.rw_type])
 
     def check_getitem_with_type(self, tp):
-        b = tp(self.base_object)
+        item = self.getitem_type
+        b = tp(self._source)
         oldrefcount = sys.getrefcount(b)
         m = self._view(b)
-        self.assertEquals(m[0], b"a")
+        self.assertEquals(m[0], item(b"a"))
         self.assert_(isinstance(m[0], bytes), type(m[0]))
-        self.assertEquals(m[5], b"f")
-        self.assertEquals(m[-1], b"f")
-        self.assertEquals(m[-6], b"a")
+        self.assertEquals(m[5], item(b"f"))
+        self.assertEquals(m[-1], item(b"f"))
+        self.assertEquals(m[-6], item(b"a"))
         # Bounds checking
         self.assertRaises(IndexError, lambda: m[6])
         self.assertRaises(IndexError, lambda: m[-7])
@@ -38,14 +44,14 @@
         m = None
         self.assertEquals(sys.getrefcount(b), oldrefcount)
 
-    def test_getitem_readonly(self):
-        self.check_getitem_with_type(bytes)
-
-    def test_getitem_writable(self):
-        self.check_getitem_with_type(bytearray)
+    def test_getitem(self):
+        for tp in self._types:
+            self.check_getitem_with_type(tp)
 
     def test_setitem_readonly(self):
-        b = self.base_object
+        if not self.ro_type:
+            return
+        b = self.ro_type(self._source)
         oldrefcount = sys.getrefcount(b)
         m = self._view(b)
         def setitem(value):
@@ -57,27 +63,30 @@
         self.assertEquals(sys.getrefcount(b), oldrefcount)
 
     def test_setitem_writable(self):
-        b = bytearray(self.base_object)
+        if not self.rw_type:
+            return
+        tp = self.rw_type
+        b = self.rw_type(self._source)
         oldrefcount = sys.getrefcount(b)
         m = self._view(b)
-        m[0] = b"0"
-        self._check_contents(b, b"0bcdef")
-        m[1:3] = b"12"
-        self._check_contents(b, b"012def")
-        m[1:1] = b""
-        self._check_contents(b, b"012def")
-        m[:] = b"abcdef"
-        self._check_contents(b, b"abcdef")
+        m[0] = tp(b"0")
+        self._check_contents(tp, b, b"0bcdef")
+        m[1:3] = tp(b"12")
+        self._check_contents(tp, b, b"012def")
+        m[1:1] = tp(b"")
+        self._check_contents(tp, b, b"012def")
+        m[:] = tp(b"abcdef")
+        self._check_contents(tp, b, b"abcdef")
 
         # Overlapping copies of a view into itself
         m[0:3] = m[2:5]
-        self._check_contents(b, b"cdedef")
-        m[:] = b"abcdef"
+        self._check_contents(tp, b, b"cdedef")
+        m[:] = tp(b"abcdef")
         m[2:5] = m[0:3]
-        self._check_contents(b, b"ababcf")
+        self._check_contents(tp, b, b"ababcf")
 
         def setitem(key, value):
-            m[key] = value
+            m[key] = tp(value)
         # Bounds checking
         self.assertRaises(IndexError, setitem, 6, b"a")
         self.assertRaises(IndexError, setitem, -7, b"a")
@@ -96,159 +105,224 @@
         m = None
         self.assertEquals(sys.getrefcount(b), oldrefcount)
 
-    def test_len(self):
-        self.assertEquals(len(self._view(self.base_object)), 6)
-
     def test_tobytes(self):
-        m = self._view(self.base_object)
-        b = m.tobytes()
-        self.assertEquals(b, b"abcdef")
-        self.assert_(isinstance(b, bytes), type(b))
+        for tp in self._types:
+            m = self._view(tp(self._source))
+            b = m.tobytes()
+            # This calls self.getitem_type() on each separate byte of b"abcdef"
+            expected = b"".join(
+                self.getitem_type(bytes([c])) for c in b"abcdef")
+            self.assertEquals(b, expected)
+            self.assert_(isinstance(b, bytes), type(b))
 
     def test_tolist(self):
-        m = self._view(self.base_object)
-        l = m.tolist()
-        self.assertEquals(l, list(b"abcdef"))
+        for tp in self._types:
+            m = self._view(tp(self._source))
+            l = m.tolist()
+            self.assertEquals(l, list(b"abcdef"))
 
     def test_compare(self):
         # memoryviews can compare for equality with other objects
         # having the buffer interface.
-        m = self._view(self.base_object)
-        for tp in (bytes, bytearray):
-            self.assertTrue(m == tp(b"abcdef"))
-            self.assertFalse(m != tp(b"abcdef"))
-            self.assertFalse(m == tp(b"abcde"))
-            self.assertTrue(m != tp(b"abcde"))
-            self.assertFalse(m == tp(b"abcde1"))
-            self.assertTrue(m != tp(b"abcde1"))
-        self.assertTrue(m == m)
-        self.assertTrue(m == m[:])
-        self.assertTrue(m[0:6] == m[:])
-        self.assertFalse(m[0:5] == m)
+        for tp in self._types:
+            m = self._view(tp(self._source))
+            for tp_comp in self._types:
+                self.assertTrue(m == tp_comp(b"abcdef"))
+                self.assertFalse(m != tp_comp(b"abcdef"))
+                self.assertFalse(m == tp_comp(b"abcde"))
+                self.assertTrue(m != tp_comp(b"abcde"))
+                self.assertFalse(m == tp_comp(b"abcde1"))
+                self.assertTrue(m != tp_comp(b"abcde1"))
+            self.assertTrue(m == m)
+            self.assertTrue(m == m[:])
+            self.assertTrue(m[0:6] == m[:])
+            self.assertFalse(m[0:5] == m)
 
-        # Comparison with objects which don't support the buffer API
-        self.assertFalse(m == "abc")
-        self.assertTrue(m != "abc")
-        self.assertFalse("abc" == m)
-        self.assertTrue("abc" != m)
+            # Comparison with objects which don't support the buffer API
+            self.assertFalse(m == "abcdef")
+            self.assertTrue(m != "abcdef")
+            self.assertFalse("abcdef" == m)
+            self.assertTrue("abcdef" != m)
 
-        # Unordered comparisons
-        for c in (m, b"abcdef"):
-            self.assertRaises(TypeError, lambda: m < c)
-            self.assertRaises(TypeError, lambda: c <= m)
-            self.assertRaises(TypeError, lambda: m >= c)
-            self.assertRaises(TypeError, lambda: c > m)
+            # Unordered comparisons
+            for c in (m, b"abcdef"):
+                self.assertRaises(TypeError, lambda: m < c)
+                self.assertRaises(TypeError, lambda: c <= m)
+                self.assertRaises(TypeError, lambda: m >= c)
+                self.assertRaises(TypeError, lambda: c > m)
 
     def check_attributes_with_type(self, tp):
-        b = tp(self.base_object)
-        m = self._view(b)
-        self.assertEquals(m.format, 'B')
-        self.assertEquals(m.itemsize, 1)
+        m = self._view(tp(self._source))
+        self.assertEquals(m.format, self.format)
+        self.assertEquals(m.itemsize, self.itemsize)
         self.assertEquals(m.ndim, 1)
         self.assertEquals(m.shape, (6,))
         self.assertEquals(len(m), 6)
-        self.assertEquals(m.strides, (1,))
+        self.assertEquals(m.strides, (self.itemsize,))
         self.assertEquals(m.suboffsets, None)
         return m
 
     def test_attributes_readonly(self):
-        m = self.check_attributes_with_type(bytes)
+        if not self.ro_type:
+            return
+        m = self.check_attributes_with_type(self.ro_type)
         self.assertEquals(m.readonly, True)
 
     def test_attributes_writable(self):
-        m = self.check_attributes_with_type(bytearray)
+        if not self.rw_type:
+            return
+        m = self.check_attributes_with_type(self.rw_type)
         self.assertEquals(m.readonly, False)
 
     def test_getbuffer(self):
         # Test PyObject_GetBuffer() on a memoryview object.
-        b = self.base_object
-        oldrefcount = sys.getrefcount(b)
-        m = self._view(b)
-        oldviewrefcount = sys.getrefcount(m)
-        s = str(m, "utf-8")
-        self._check_contents(b, s.encode("utf-8"))
-        self.assertEquals(sys.getrefcount(m), oldviewrefcount)
-        m = None
-        self.assertEquals(sys.getrefcount(b), oldrefcount)
+        for tp in self._types:
+            b = tp(self._source)
+            oldrefcount = sys.getrefcount(b)
+            m = self._view(b)
+            oldviewrefcount = sys.getrefcount(m)
+            s = str(m, "utf-8")
+            self._check_contents(tp, b, s.encode("utf-8"))
+            self.assertEquals(sys.getrefcount(m), oldviewrefcount)
+            m = None
+            self.assertEquals(sys.getrefcount(b), oldrefcount)
 
     def test_gc(self):
-        class MyBytes(bytes):
-            pass
-        class MyObject:
-            pass
+        for tp in self._types:
+            if not isinstance(tp, type):
+                # If tp is a factory rather than a plain type, skip
+                continue
 
-        # Create a reference cycle through a memoryview object
-        b = MyBytes(b'abc')
-        m = self._view(b)
-        o = MyObject()
-        b.m = m
-        b.o = o
-        wr = weakref.ref(o)
-        b = m = o = None
-        # The cycle must be broken
-        gc.collect()
-        self.assert_(wr() is None, wr())
+            class MySource(tp):
+                pass
+            class MyObject:
+                pass
+
+            # Create a reference cycle through a memoryview object
+            b = MySource(tp(b'abc'))
+            m = self._view(b)
+            o = MyObject()
+            b.m = m
+            b.o = o
+            wr = weakref.ref(o)
+            b = m = o = None
+            # The cycle must be broken
+            gc.collect()
+            self.assert_(wr() is None, wr())
 
 
-class MemoryviewTest(unittest.TestCase, CommonMemoryTests):
+# Variations on source objects for the buffer: bytes-like objects, then arrays
+# with itemsize > 1.
+# NOTE: support for multi-dimensional objects is unimplemented.
 
+class BaseBytesMemoryTests(AbstractMemoryTests):
+    ro_type = bytes
+    rw_type = bytearray
+    getitem_type = bytes
+    itemsize = 1
+    format = 'B'
+
+class BaseArrayMemoryTests(AbstractMemoryTests):
+    ro_type = None
+    rw_type = lambda self, b: array.array('i', list(b))
+    getitem_type = lambda self, b: array.array('i', list(b)).tostring()
+    itemsize = array.array('i').itemsize
+    format = 'i'
+
+    def test_getbuffer(self):
+        # XXX Test should be adapted for non-byte buffers
+        pass
+
+    def test_tolist(self):
+        # XXX NotImplementedError: tolist() only supports byte views
+        pass
+
+
+# Variations on indirection levels: memoryview, slice of memoryview,
+# slice of slice of memoryview.
+# This is important to test allocation subtleties.
+
+class BaseMemoryviewTests:
     def _view(self, obj):
         return memoryview(obj)
 
-    def _check_contents(self, obj, contents):
-        self.assertEquals(obj, contents)
+    def _check_contents(self, tp, obj, contents):
+        self.assertEquals(obj, tp(contents))
 
-    def test_constructor(self):
-        ob = b'test'
-        self.assert_(memoryview(ob))
-        self.assert_(memoryview(object=ob))
-        self.assertRaises(TypeError, memoryview)
-        self.assertRaises(TypeError, memoryview, ob, ob)
-        self.assertRaises(TypeError, memoryview, argument=ob)
-        self.assertRaises(TypeError, memoryview, ob, argument=True)
-
-    def test_array_assign(self):
-        # Issue #4569: segfault when mutating a memoryview with itemsize != 1
-        from array import array
-        a = array('i', range(10))
-        m = memoryview(a)
-        new_a = array('i', range(9, -1, -1))
-        m[:] = new_a
-        self.assertEquals(a, new_a)
-
-
-class MemorySliceTest(unittest.TestCase, CommonMemoryTests):
-    base_object = b"XabcdefY"
+class BaseMemorySliceTests:
+    source_bytes = b"XabcdefY"
 
     def _view(self, obj):
         m = memoryview(obj)
         return m[1:7]
 
-    def _check_contents(self, obj, contents):
-        self.assertEquals(obj[1:7], contents)
+    def _check_contents(self, tp, obj, contents):
+        self.assertEquals(obj[1:7], tp(contents))
 
     def test_refs(self):
-        m = memoryview(b"ab")
-        oldrefcount = sys.getrefcount(m)
-        m[1:2]
-        self.assertEquals(sys.getrefcount(m), oldrefcount)
+        for tp in self._types:
+            m = memoryview(tp(self._source))
+            oldrefcount = sys.getrefcount(m)
+            m[1:2]
+            self.assertEquals(sys.getrefcount(m), oldrefcount)
 
-
-class MemorySliceSliceTest(unittest.TestCase, CommonMemoryTests):
-    base_object = b"XabcdefY"
+class BaseMemorySliceSliceTests:
+    source_bytes = b"XabcdefY"
 
     def _view(self, obj):
         m = memoryview(obj)
         return m[:7][1:]
 
-    def _check_contents(self, obj, contents):
-        self.assertEquals(obj[1:7], contents)
+    def _check_contents(self, tp, obj, contents):
+        self.assertEquals(obj[1:7], tp(contents))
+
+
+# Concrete test classes
+
+class BytesMemoryviewTest(unittest.TestCase,
+    BaseMemoryviewTests, BaseBytesMemoryTests):
+
+    def test_constructor(self):
+        for tp in self._types:
+            ob = tp(self._source)
+            self.assert_(memoryview(ob))
+            self.assert_(memoryview(object=ob))
+            self.assertRaises(TypeError, memoryview)
+            self.assertRaises(TypeError, memoryview, ob, ob)
+            self.assertRaises(TypeError, memoryview, argument=ob)
+            self.assertRaises(TypeError, memoryview, ob, argument=True)
+
+class ArrayMemoryviewTest(unittest.TestCase,
+    BaseMemoryviewTests, BaseArrayMemoryTests):
+
+    def test_array_assign(self):
+        # Issue #4569: segfault when mutating a memoryview with itemsize != 1
+        a = array.array('i', range(10))
+        m = memoryview(a)
+        new_a = array.array('i', range(9, -1, -1))
+        m[:] = new_a
+        self.assertEquals(a, new_a)
+
+
+class BytesMemorySliceTest(unittest.TestCase,
+    BaseMemorySliceTests, BaseBytesMemoryTests):
+    pass
+
+class ArrayMemorySliceTest(unittest.TestCase,
+    BaseMemorySliceTests, BaseArrayMemoryTests):
+    pass
+
+class BytesMemorySliceSliceTest(unittest.TestCase,
+    BaseMemorySliceSliceTests, BaseBytesMemoryTests):
+    pass
+
+class ArrayMemorySliceSliceTest(unittest.TestCase,
+    BaseMemorySliceSliceTests, BaseArrayMemoryTests):
+    pass
 
 
 def test_main():
-    test.support.run_unittest(
-        MemoryviewTest, MemorySliceTest, MemorySliceSliceTest)
-
+    test.support.run_unittest(__name__)
 
 if __name__ == "__main__":
     test_main()
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index a8c19ee..7655fbf 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -559,7 +559,7 @@
         check(32768*32768-1, size(vh) + 2*self.H)
         check(32768*32768, size(vh) + 3*self.H)
         # memory
-        check(memoryview(b''), size(h + 'P PP2P2i5P'))
+        check(memoryview(b''), size(h + 'P PP2P2i7P'))
         # module
         check(unittest, size(h + '3P'))
         # None