Index: src/org/python/core/PySequence.java
===================================================================
--- src/org/python/core/PySequence.java	(revision 3454)
+++ src/org/python/core/PySequence.java	(working copy)
@@ -302,7 +302,7 @@
     protected static final int getStep(PyObject s_step) {
         int step = getIndex(s_step, 1);
         if (step == 0) {
-            throw Py.TypeError("slice step of zero not allowed");
+            throw Py.ValueError("slice step cannot be zero");
         }
         return step;
     }
Index: src/org/python/core/PyTuple.java
===================================================================
--- src/org/python/core/PyTuple.java	(revision 3454)
+++ src/org/python/core/PyTuple.java	(working copy)
@@ -390,7 +390,12 @@
     }
 
     protected PyObject repeat(int count) {
-
+        if (count < 0) {
+            count = 0;
+        }
+        if (size() == 0 || count == 1) {
+            return this;
+        }
         PyObject[] array = getArray();
         int l = size();
         PyObject[] newArray = new PyObject[l*count];
Index: src/org/python/core/PyList.java
===================================================================
--- src/org/python/core/PyList.java	(revision 3454)
+++ src/org/python/core/PyList.java	(working copy)
@@ -719,6 +719,8 @@
     final void list_init(PyObject[] args,String[] kwds) {
         ArgParser ap = new ArgParser("list", args, kwds, new String[] { "sequence"}, 0);
         PyObject seq = ap.getPyObject(0, null);
+
+        clear();
         if (seq == null) {
             return;
         }
@@ -791,119 +793,106 @@
         list.pyset(i, value);
     }
 
-//    protected void setslice(int start, int stop, int step, PyObject value) {
-//
-//        if (step != 1)
-//            throw Py.ValueError("step size must be 1 for setting list slice");
-//        if (stop < start)
-//            stop = start;
-//        
-//        if (value instanceof PySequenceList) {
-//            
-//            if (value instanceof PyList) {
-//                PyObject[] otherArray = null;
-//                PyObject[] array = getArray(); 
-//                   PySequenceList seqList = (PySequenceList)value;
-//                   otherArray = seqList.getArray();
-//                   if (otherArray == array) {
-//                       otherArray = (PyObject[])otherArray.clone();
-//                   }
-//                   list.replaceSubArray(start, stop, otherArray, 0, seqList.size());
-//            } else {
-//                   throw Py.TypeError("can only concatenate list (not \"" +
-//                           value.getType() + "\") to list");
-//            }
-//        } else { 
-//            
-//            // also allow java.util.List
-//            List other = (List)value.__tojava__(List.class);
-//            if(other != Py.NoConversion) {
-//                   int n = other.size();
-//                   list.ensureCapacity(start + n);
-//                   for(int i=0; i<n; i++) {
-//                       list.add(i+start, other.get(i));
-//                   }
-//            } else {        
-//                throw Py.TypeError(
-//                              "rhs of setslice must be a sequence or java.util.List");
-//            }
-//        }
-//    }    
     protected void setslice(int start, int stop, int step, PyObject value) {
-
         if (stop < start)
             stop = start;
         
+        if (value instanceof PySequence) {
+            PySequence sequence = (PySequence)value;
+            setslicePySequence(start, stop, step, sequence);
+        }
+        else if (value instanceof List) {
+            List list = (List)value.__tojava__(List.class);
+            if (list != null && list != Py.NoConversion) {
+                setsliceList(start, stop, step, list);
+            }
+        }
+        else {
+            setsliceIterable(start, stop, step, value);
+        }
+    }
+
+    protected void setslicePySequence(int start, int stop, int step, PySequence value) {
         if (step == 1) {
-            if (value instanceof PySequence) {
-            
-                PySequence seq = (PySequence)value;
+            PyObject[] otherArray = null;
+            PyObject[] array = getArray(); 
 
-                PyObject[] otherArray = null;
-                PyObject[] array = getArray(); 
-
-                if (value instanceof PySequenceList) {
-                    PySequenceList seqList = (PySequenceList)value;
-                    otherArray = seqList.getArray();
-                    if (otherArray == array) {
-                        otherArray = otherArray.clone();
-                    }
-                    list.replaceSubArray(start, stop, otherArray, 0, seqList.size());
-                } else {
-                    int n = seq.__len__();
-                    list.ensureCapacity(start + n);
-                    for(int i=0; i<n; i++) {
-                        list.add(i+start, seq.pyget(i));
-                    }
+            if (value instanceof PySequenceList) {
+                PySequenceList seqList = (PySequenceList)value;
+                otherArray = seqList.getArray();
+                if (otherArray == array) {
+                    otherArray = otherArray.clone();
                 }
-            } else if (value instanceof List) { 
-                    List other = (List)value.__tojava__(List.class);
-                    if(other != Py.NoConversion && other != null) {
-                        int n = other.size();
-                        list.ensureCapacity(start + n);
-                        for(int i=0; i<n; i++) {
-                            list.add(i+start, other.get(i));
-                        }
-                    }
-            } else {        
-                throw Py.TypeError(
-                                "rhs of setslice must be a sequence or java.util.List");
+                list.replaceSubArray(start, stop, otherArray, 0, seqList.size());
             }
-        } else if (step > 1){
-            if (value instanceof PySequence) {
-                PySequence seq = (PySequence)value;
-                int n = seq.__len__();
-                for(int i=0,j=0; i<n; i++,j+=step) {
-                    list.pyset(j+start, seq.pyget(i));
+            else {
+                int n = value.__len__();
+                list.ensureCapacity(start + n);
+                for (int i=0; i < n; i++) {
+                    list.add(i + start, value.pyget(i));
                 }
-            } else {
-                throw Py.TypeError(
-                             "setslice with java.util.List and step != 1 not supported yet.");
             }
-                
-        } else if (step < 0) {
-            if (value instanceof PySequence) {
-                PySequence seq = (PySequence)value;
-                int n = seq.__len__();
-                if (seq == this) {
-                    PyList newseq = new PyList();
-                    PyObject iter = seq.__iter__();
-                    for (PyObject item = null; (item = iter.__iternext__()) != null; ) {
-                        newseq.append(item);
-                    }
-                    seq = newseq;
+        }
+        else if (step > 1) {
+            int n = value.__len__();
+            for (int i=0, j=0; i < n; i++, j += step) {
+                list.pyset(j + start, value.pyget(i));
+            }
+        }
+        else if (step < 0) {
+            int n = value.__len__();
+            if (value == this) {
+                PyList newseq = new PyList();
+                PyObject iter = value.__iter__();
+                for (PyObject item = null; (item = iter.__iternext__()) != null;) {
+                    newseq.append(item);
                 }
-                for(int i=0,j=list.size() - 1; i<n; i++,j+=step) {
-                    list.pyset(j, seq.pyget(i));
-                }
-            } else {
-                throw Py.TypeError(
-                            "setslice with java.util.List and step != 1 not supported yet.");
+                value = newseq;
             }
-         }
+            for (int i=0, j=list.size() - 1; i < n; i++, j += step) {
+                list.pyset(j, value.pyget(i));
+            }
+        }
     }
-    
+
+    protected void setsliceList(int start, int stop, int step, List value) {
+        if (step != 1) {
+            throw Py.TypeError("setslice with java.util.List and step != 1 not " +
+                               "supported yet");
+        }
+        int n = value.size();
+        list.ensureCapacity(start + n);
+        for(int i=0; i < n; i++) {
+            list.add(i + start, value.get(i));
+        }
+    }
+
+    protected void setsliceIterable(int start, int stop, int step, PyObject value) {
+        PyObject iter;
+        try {
+            iter = value.__iter__();
+        }
+        catch (PyException pye) {
+            if (Py.matchException(pye, Py.TypeError)) {
+                throw Py.TypeError("can only assign an iterable");
+            }
+            throw pye;
+        }
+        PyObject next;
+        for (int j = 0; (next = iter.__iternext__()) != null; j += step) {
+            if (step < 0) {
+                list.pyset(start + j, next);
+            }
+            else {
+                list.add(start + j, next);
+            }
+        }
+    }
+
     protected PyObject repeat(int count) {
+        if (count < 0) {
+            count = 0;
+        }
         int l = size();
         PyObject[] newList = new PyObject[l*count];
         for (int i=0; i<count; i++) {
@@ -1121,14 +1110,12 @@
         int validStart = calculateIndex(start);
         
         PyObject[] array = getArray();
-        int i=validStart;
-        for (; i<validStop; i++) {
+        int i = validStart;
+        for (; i < validStop && i < size(); i++) {
             if (array[i].equals(o))
-                break;
+                return i;
         }
-        if (i == validStop)
-            throw Py.ValueError(message);
-        return i;
+        throw Py.ValueError(message);
     }    
 
     //This is closely related to fixindex in PySequence, but less strict
@@ -1287,8 +1274,12 @@
     }
 
     final synchronized void list_sort(PyObject compare) {
-        MergeState ms = new MergeState(getArray(), size(), compare);
+        int size = size();
+        MergeState ms = new MergeState(getArray(), size, compare);
         ms.sort();
+        if (size != size()) {
+            throw Py.ValueError("list modified during sort");
+        }
     }
 
     /**
Index: Lib/test/seq_tests.py
===================================================================
--- Lib/test/seq_tests.py	(revision 0)
+++ Lib/test/seq_tests.py	(revision 0)
@@ -0,0 +1,206 @@
+"""
+Tests common to tuple, list and UserList.UserList
+"""
+
+import unittest
+from test import test_support
+
+class CommonTest(unittest.TestCase):
+    # The type to be tested
+    type2test = None
+
+    def test_constructors(self):
+        l0 = []
+        l1 = [0]
+        l2 = [0, 1]
+
+        u = self.type2test()
+        u0 = self.type2test(l0)
+        u1 = self.type2test(l1)
+        u2 = self.type2test(l2)
+
+        uu = self.type2test(u)
+        uu0 = self.type2test(u0)
+        uu1 = self.type2test(u1)
+        uu2 = self.type2test(u2)
+
+        v = self.type2test(tuple(u))
+        class OtherSeq:
+            def __init__(self, initseq):
+                self.__data = initseq
+            def __len__(self):
+                return len(self.__data)
+            def __getitem__(self, i):
+                return self.__data[i]
+        s = OtherSeq(u0)
+        v0 = self.type2test(s)
+        self.assertEqual(len(v0), len(s))
+
+        s = "this is also a sequence"
+        vv = self.type2test(s)
+        self.assertEqual(len(vv), len(s))
+
+    def test_truth(self):
+        self.assert_(not self.type2test())
+        self.assert_(self.type2test([42]))
+
+    def test_getitem(self):
+        u = self.type2test([0, 1, 2, 3, 4])
+        for i in xrange(len(u)):
+            self.assertEqual(u[i], i)
+            self.assertEqual(u[long(i)], i)
+        for i in xrange(-len(u), -1):
+            self.assertEqual(u[i], len(u)+i)
+            self.assertEqual(u[long(i)], len(u)+i)
+        self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
+        self.assertRaises(IndexError, u.__getitem__, len(u))
+        self.assertRaises(ValueError, u.__getitem__, slice(0,10,0))
+
+        u = self.type2test()
+        self.assertRaises(IndexError, u.__getitem__, 0)
+        self.assertRaises(IndexError, u.__getitem__, -1)
+
+        self.assertRaises(TypeError, u.__getitem__)
+
+        a = self.type2test([10, 11])
+        self.assertEqual(a[0], 10)
+        self.assertEqual(a[1], 11)
+        self.assertEqual(a[-2], 10)
+        self.assertEqual(a[-1], 11)
+        self.assertRaises(IndexError, a.__getitem__, -3)
+        self.assertRaises(IndexError, a.__getitem__, 3)
+
+    def test_getslice(self):
+        l = [0, 1, 2, 3, 4]
+        u = self.type2test(l)
+
+        self.assertEqual(u[0:0], self.type2test())
+        self.assertEqual(u[1:2], self.type2test([1]))
+        self.assertEqual(u[-2:-1], self.type2test([3]))
+        self.assertEqual(u[-1000:1000], u)
+        self.assertEqual(u[1000:-1000], self.type2test([]))
+        self.assertEqual(u[:], u)
+        self.assertEqual(u[1:None], self.type2test([1, 2, 3, 4]))
+        self.assertEqual(u[None:3], self.type2test([0, 1, 2]))
+
+        # Extended slices
+        self.assertEqual(u[::], u)
+        self.assertEqual(u[::2], self.type2test([0, 2, 4]))
+        self.assertEqual(u[1::2], self.type2test([1, 3]))
+        self.assertEqual(u[::-1], self.type2test([4, 3, 2, 1, 0]))
+        self.assertEqual(u[::-2], self.type2test([4, 2, 0]))
+        self.assertEqual(u[3::-2], self.type2test([3, 1]))
+        self.assertEqual(u[3:3:-2], self.type2test([]))
+        self.assertEqual(u[3:2:-2], self.type2test([3]))
+        self.assertEqual(u[3:1:-2], self.type2test([3]))
+        self.assertEqual(u[3:0:-2], self.type2test([3, 1]))
+        self.assertEqual(u[::-100], self.type2test([4]))
+        self.assertEqual(u[100:-100:], self.type2test([]))
+        self.assertEqual(u[-100:100:], u)
+        self.assertEqual(u[100:-100:-1], u[::-1])
+        self.assertEqual(u[-100:100:-1], self.type2test([]))
+        self.assertEqual(u[-100L:100L:2L], self.type2test([0, 2, 4]))
+
+        # Test extreme cases with long ints
+        a = self.type2test([0,1,2,3,4])
+        self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2]))
+        self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4]))
+
+        self.assertRaises(TypeError, u.__getslice__)
+
+    def test_contains(self):
+        u = self.type2test([0, 1, 2])
+        for i in u:
+            self.assert_(i in u)
+        for i in min(u)-1, max(u)+1:
+            self.assert_(i not in u)
+
+        self.assertRaises(TypeError, u.__contains__)
+
+    def test_len(self):
+        self.assertEqual(len(self.type2test()), 0)
+        self.assertEqual(len(self.type2test([])), 0)
+        self.assertEqual(len(self.type2test([0])), 1)
+        self.assertEqual(len(self.type2test([0, 1, 2])), 3)
+
+    def test_minmax(self):
+        u = self.type2test([0, 1, 2])
+        self.assertEqual(min(u), 0)
+        self.assertEqual(max(u), 2)
+
+    def test_addmul(self):
+        u1 = self.type2test([0])
+        u2 = self.type2test([0, 1])
+        self.assertEqual(u1, u1 + self.type2test())
+        self.assertEqual(u1, self.type2test() + u1)
+        self.assertEqual(u1 + self.type2test([1]), u2)
+        self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
+        self.assertEqual(self.type2test(), u2*0)
+        self.assertEqual(self.type2test(), 0*u2)
+        self.assertEqual(self.type2test(), u2*0L)
+        self.assertEqual(self.type2test(), 0L*u2)
+        self.assertEqual(u2, u2*1)
+        self.assertEqual(u2, 1*u2)
+        self.assertEqual(u2, u2*1L)
+        self.assertEqual(u2, 1L*u2)
+        self.assertEqual(u2+u2, u2*2)
+        self.assertEqual(u2+u2, 2*u2)
+        self.assertEqual(u2+u2, u2*2L)
+        self.assertEqual(u2+u2, 2L*u2)
+        self.assertEqual(u2+u2+u2, u2*3)
+        self.assertEqual(u2+u2+u2, 3*u2)
+
+        class subclass(self.type2test):
+            pass
+        u3 = subclass([0, 1])
+        self.assertEqual(u3, u3*1)
+        self.assert_(u3 is not u3*1)
+
+    def test_iadd(self):
+        u = self.type2test([0, 1])
+        u += self.type2test()
+        self.assertEqual(u, self.type2test([0, 1]))
+        u += self.type2test([2, 3])
+        self.assertEqual(u, self.type2test([0, 1, 2, 3]))
+        u += self.type2test([4, 5])
+        self.assertEqual(u, self.type2test([0, 1, 2, 3, 4, 5]))
+
+        u = self.type2test("spam")
+        u += self.type2test("eggs")
+        self.assertEqual(u, self.type2test("spameggs"))
+
+    def test_imul(self):
+        u = self.type2test([0, 1])
+        u *= 3
+        self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
+
+    def test_getitemoverwriteiter(self):
+        # Verify that __getitem__ overrides are not recognized by __iter__
+        class T(self.type2test):
+            def __getitem__(self, key):
+                return str(key) + '!!!'
+        self.assertEqual(iter(T((1,2))).next(), 1)
+
+    def test_repeat(self):
+        for m in xrange(4):
+            s = tuple(range(m))
+            for n in xrange(-3, 5):
+                self.assertEqual(self.type2test(s*n), self.type2test(s)*n)
+            self.assertEqual(self.type2test(s)*(-4), self.type2test([]))
+            self.assertEqual(id(s), id(s*1))
+
+    def test_subscript(self):
+        a = self.type2test([10, 11])
+        self.assertEqual(a.__getitem__(0L), 10)
+        self.assertEqual(a.__getitem__(1L), 11)
+        self.assertEqual(a.__getitem__(-2L), 10)
+        self.assertEqual(a.__getitem__(-1L), 11)
+        self.assertRaises(IndexError, a.__getitem__, -3)
+        self.assertRaises(IndexError, a.__getitem__, 3)
+        self.assertEqual(a.__getitem__(slice(0,1)), self.type2test([10]))
+        self.assertEqual(a.__getitem__(slice(1,2)), self.type2test([11]))
+        self.assertEqual(a.__getitem__(slice(0,2)), self.type2test([10, 11]))
+        self.assertEqual(a.__getitem__(slice(0,3)), self.type2test([10, 11]))
+        self.assertEqual(a.__getitem__(slice(3,5)), self.type2test([]))
+        self.assertRaises(ValueError, a.__getitem__, slice(0, 10, 0))
+        self.assertRaises(TypeError, a.__getitem__, 'x')
Index: Lib/test/list_tests.py
===================================================================
--- Lib/test/list_tests.py	(revision 0)
+++ Lib/test/list_tests.py	(revision 0)
@@ -0,0 +1,510 @@
+"""
+Tests common to list and UserList.UserList
+"""
+
+import sys
+import os
+
+import unittest
+from test import test_support, seq_tests
+
+class CommonTest(seq_tests.CommonTest):
+
+    def test_init(self):
+        # Iterable arg is optional
+        self.assertEqual(self.type2test([]), self.type2test())
+
+        # Init clears previous values
+        a = self.type2test([1, 2, 3])
+        a.__init__()
+        self.assertEqual(a, self.type2test([]))
+
+        # Init overwrites previous values
+        a = self.type2test([1, 2, 3])
+        a.__init__([4, 5, 6])
+        self.assertEqual(a, self.type2test([4, 5, 6]))
+
+        # Mutables always return a new object
+        b = self.type2test(a)
+        self.assertNotEqual(id(a), id(b))
+        self.assertEqual(a, b)
+
+    def test_repr(self):
+        l0 = []
+        l2 = [0, 1, 2]
+        a0 = self.type2test(l0)
+        a2 = self.type2test(l2)
+
+        self.assertEqual(str(a0), str(l0))
+        self.assertEqual(repr(a0), repr(l0))
+        self.assertEqual(`a2`, `l2`)
+        self.assertEqual(str(a2), "[0, 1, 2]")
+        self.assertEqual(repr(a2), "[0, 1, 2]")
+
+        a2.append(a2)
+        a2.append(3)
+        self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
+        self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
+
+    def test_print(self):
+        d = self.type2test(xrange(200))
+        d.append(d)
+        d.extend(xrange(200,400))
+        d.append(d)
+        d.append(400)
+        try:
+            fo = open(test_support.TESTFN, "wb")
+            print >> fo, d,
+            fo.close()
+            fo = open(test_support.TESTFN, "rb")
+            self.assertEqual(fo.read(), repr(d))
+        finally:
+            fo.close()
+            os.remove(test_support.TESTFN)
+
+    def test_set_subscript(self):
+        a = self.type2test(range(20))
+        self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1,2,3])
+        self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1)
+        # XXX: Need Slice bounds checking (equiv to CPython's PySlice_GetIndicesEx)
+        #self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1,2])
+        self.assertRaises(TypeError, a.__getitem__, 'x', 1)
+        a[slice(2,10,3)] = [1,2,3]
+        self.assertEqual(a, self.type2test([0, 1, 1, 3, 4, 2, 6, 7, 3,
+                                            9, 10, 11, 12, 13, 14, 15,
+                                            16, 17, 18, 19]))
+
+    def test_reversed(self):
+        a = self.type2test(range(20))
+        r = reversed(a)
+        self.assertEqual(list(r), self.type2test(range(19, -1, -1)))
+        self.assertRaises(StopIteration, r.next)
+        self.assertEqual(list(reversed(self.type2test())),
+                         self.type2test())
+
+    def test_setitem(self):
+        a = self.type2test([0, 1])
+        a[0] = 0
+        a[1] = 100
+        self.assertEqual(a, self.type2test([0, 100]))
+        a[-1] = 200
+        self.assertEqual(a, self.type2test([0, 200]))
+        a[-2] = 100
+        self.assertEqual(a, self.type2test([100, 200]))
+        self.assertRaises(IndexError, a.__setitem__, -3, 200)
+        self.assertRaises(IndexError, a.__setitem__, 2, 200)
+
+        a = self.type2test([])
+        self.assertRaises(IndexError, a.__setitem__, 0, 200)
+        self.assertRaises(IndexError, a.__setitem__, -1, 200)
+        self.assertRaises(TypeError, a.__setitem__)
+
+        a = self.type2test([0,1,2,3,4])
+        a[0L] = 1
+        a[1L] = 2
+        a[2L] = 3
+        self.assertEqual(a, self.type2test([1,2,3,3,4]))
+        a[0] = 5
+        a[1] = 6
+        a[2] = 7
+        self.assertEqual(a, self.type2test([5,6,7,3,4]))
+        a[-2L] = 88
+        a[-1L] = 99
+        self.assertEqual(a, self.type2test([5,6,7,88,99]))
+        a[-2] = 8
+        a[-1] = 9
+        self.assertEqual(a, self.type2test([5,6,7,8,9]))
+
+    def test_delitem(self):
+        a = self.type2test([0, 1])
+        del a[1]
+        self.assertEqual(a, [0])
+        del a[0]
+        self.assertEqual(a, [])
+
+        a = self.type2test([0, 1])
+        del a[-2]
+        self.assertEqual(a, [1])
+        del a[-1]
+        self.assertEqual(a, [])
+
+        a = self.type2test([0, 1])
+        self.assertRaises(IndexError, a.__delitem__, -3)
+        self.assertRaises(IndexError, a.__delitem__, 2)
+
+        a = self.type2test([])
+        self.assertRaises(IndexError, a.__delitem__, 0)
+
+        self.assertRaises(TypeError, a.__delitem__)
+
+    def test_setslice(self):
+        l = [0, 1]
+        a = self.type2test(l)
+
+        for i in range(-3, 4):
+            a[:i] = l[:i]
+            self.assertEqual(a, l)
+            a2 = a[:]
+            a2[:i] = a[:i]
+            self.assertEqual(a2, a)
+            a[i:] = l[i:]
+            self.assertEqual(a, l)
+            a2 = a[:]
+            a2[i:] = a[i:]
+            self.assertEqual(a2, a)
+            for j in range(-3, 4):
+                a[i:j] = l[i:j]
+                self.assertEqual(a, l)
+                a2 = a[:]
+                a2[i:j] = a[i:j]
+                self.assertEqual(a2, a)
+
+        aa2 = a2[:]
+        aa2[:0] = [-2, -1]
+        self.assertEqual(aa2, [-2, -1, 0, 1])
+        aa2[0:] = []
+        self.assertEqual(aa2, [])
+
+        a = self.type2test([1, 2, 3, 4, 5])
+        a[:-1] = a
+        self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 5]))
+        a = self.type2test([1, 2, 3, 4, 5])
+        a[1:] = a
+        self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5]))
+        a = self.type2test([1, 2, 3, 4, 5])
+        a[1:-1] = a
+        self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5, 5]))
+
+        a = self.type2test([])
+        a[:] = tuple(range(10))
+        self.assertEqual(a, self.type2test(range(10)))
+
+        self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
+
+        self.assertRaises(TypeError, a.__setslice__)
+
+    def test_delslice(self):
+        a = self.type2test([0, 1])
+        del a[1:2]
+        del a[0:1]
+        self.assertEqual(a, self.type2test([]))
+
+        a = self.type2test([0, 1])
+        del a[1L:2L]
+        del a[0L:1L]
+        self.assertEqual(a, self.type2test([]))
+
+        a = self.type2test([0, 1])
+        del a[-2:-1]
+        self.assertEqual(a, self.type2test([1]))
+
+        a = self.type2test([0, 1])
+        del a[-2L:-1L]
+        self.assertEqual(a, self.type2test([1]))
+
+        a = self.type2test([0, 1])
+        del a[1:]
+        del a[:1]
+        self.assertEqual(a, self.type2test([]))
+
+        a = self.type2test([0, 1])
+        del a[1L:]
+        del a[:1L]
+        self.assertEqual(a, self.type2test([]))
+
+        a = self.type2test([0, 1])
+        del a[-1:]
+        self.assertEqual(a, self.type2test([0]))
+
+        a = self.type2test([0, 1])
+        del a[-1L:]
+        self.assertEqual(a, self.type2test([0]))
+
+        a = self.type2test([0, 1])
+        del a[:]
+        self.assertEqual(a, self.type2test([]))
+
+    def test_append(self):
+        a = self.type2test([])
+        a.append(0)
+        a.append(1)
+        a.append(2)
+        self.assertEqual(a, self.type2test([0, 1, 2]))
+
+        self.assertRaises(TypeError, a.append)
+
+    def test_extend(self):
+        a1 = self.type2test([0])
+        a2 = self.type2test((0, 1))
+        a = a1[:]
+        a.extend(a2)
+        self.assertEqual(a, a1 + a2)
+
+        a.extend(self.type2test([]))
+        self.assertEqual(a, a1 + a2)
+
+        a.extend(a)
+        self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))
+
+        a = self.type2test("spam")
+        a.extend("eggs")
+        self.assertEqual(a, list("spameggs"))
+
+        self.assertRaises(TypeError, a.extend, None)
+
+        self.assertRaises(TypeError, a.extend)
+
+    def test_insert(self):
+        a = self.type2test([0, 1, 2])
+        a.insert(0, -2)
+        a.insert(1, -1)
+        a.insert(2, 0)
+        self.assertEqual(a, [-2, -1, 0, 0, 1, 2])
+
+        b = a[:]
+        b.insert(-2, "foo")
+        b.insert(-200, "left")
+        b.insert(200, "right")
+        self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))
+
+        self.assertRaises(TypeError, a.insert)
+
+    def test_pop(self):
+        # XXX: no decimal module in 2.3
+        #from decimal import Decimal
+        a = self.type2test([-1, 0, 1])
+        a.pop()
+        self.assertEqual(a, [-1, 0])
+        a.pop(0)
+        self.assertEqual(a, [0])
+        self.assertRaises(IndexError, a.pop, 5)
+        a.pop(0)
+        self.assertEqual(a, [])
+        self.assertRaises(IndexError, a.pop)
+        self.assertRaises(TypeError, a.pop, 42, 42)
+        #a = self.type2test([0, 10, 20, 30, 40])
+        #self.assertEqual(a.pop(Decimal(2)), 20)
+        #self.assertRaises(IndexError, a.pop, Decimal(25))
+
+    def test_remove(self):
+        a = self.type2test([0, 0, 1])
+        a.remove(1)
+        self.assertEqual(a, [0, 0])
+        a.remove(0)
+        self.assertEqual(a, [0])
+        a.remove(0)
+        self.assertEqual(a, [])
+
+        self.assertRaises(ValueError, a.remove, 0)
+
+        self.assertRaises(TypeError, a.remove)
+
+        class BadExc(Exception):
+            pass
+
+        class BadCmp:
+            def __eq__(self, other):
+                if other == 2:
+                    raise BadExc()
+                return False
+
+        a = self.type2test([0, 1, 2, 3])
+        self.assertRaises(BadExc, a.remove, BadCmp())
+
+    def test_count(self):
+        a = self.type2test([0, 1, 2])*3
+        self.assertEqual(a.count(0), 3)
+        self.assertEqual(a.count(1), 3)
+        self.assertEqual(a.count(3), 0)
+
+        self.assertRaises(TypeError, a.count)
+
+        class BadExc(Exception):
+            pass
+
+        class BadCmp:
+            def __eq__(self, other):
+                if other == 2:
+                    raise BadExc()
+                return False
+
+        self.assertRaises(BadExc, a.count, BadCmp())
+
+    def test_index(self):
+        u = self.type2test([0, 1])
+        self.assertEqual(u.index(0), 0)
+        self.assertEqual(u.index(1), 1)
+        self.assertRaises(ValueError, u.index, 2)
+
+        u = self.type2test([-2, -1, 0, 0, 1, 2])
+        self.assertEqual(u.count(0), 2)
+        self.assertEqual(u.index(0), 2)
+        self.assertEqual(u.index(0, 2), 2)
+        self.assertEqual(u.index(-2, -10), 0)
+        self.assertEqual(u.index(0, 3), 3)
+        self.assertEqual(u.index(0, 3, 4), 3)
+        self.assertRaises(ValueError, u.index, 2, 0, -10)
+
+        self.assertRaises(TypeError, u.index)
+
+        class BadExc(Exception):
+            pass
+
+        class BadCmp:
+            def __eq__(self, other):
+                if other == 2:
+                    raise BadExc()
+                return False
+
+        a = self.type2test([0, 1, 2, 3])
+        self.assertRaises(BadExc, a.index, BadCmp())
+
+        a = self.type2test([-2, -1, 0, 0, 1, 2])
+        self.assertEqual(a.index(0), 2)
+        self.assertEqual(a.index(0, 2), 2)
+        self.assertEqual(a.index(0, -4), 2)
+        self.assertEqual(a.index(-2, -10), 0)
+        self.assertEqual(a.index(0, 3), 3)
+        self.assertEqual(a.index(0, -3), 3)
+        self.assertEqual(a.index(0, 3, 4), 3)
+        self.assertEqual(a.index(0, -3, -2), 3)
+        # XXX: pending long/int integration of builtin's method args
+        #self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
+        #self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
+        self.assertRaises(ValueError, a.index, 2, 0, -10)
+        a.remove(0)
+        self.assertRaises(ValueError, a.index, 2, 0, 4)
+        self.assertEqual(a, self.type2test([-2, -1, 0, 1, 2]))
+
+        # Test modifying the list during index's iteration
+        class EvilCmp:
+            def __init__(self, victim):
+                self.victim = victim
+            def __eq__(self, other):
+                del self.victim[:]
+                return False
+        a = self.type2test()
+        a[:] = [EvilCmp(a) for _ in xrange(100)]
+        # This used to seg fault before patch #1005778
+        self.assertRaises(ValueError, a.index, None)
+
+    def test_reverse(self):
+        u = self.type2test([-2, -1, 0, 1, 2])
+        u2 = u[:]
+        u.reverse()
+        self.assertEqual(u, [2, 1, 0, -1, -2])
+        u.reverse()
+        self.assertEqual(u, u2)
+
+        self.assertRaises(TypeError, u.reverse, 42)
+
+    def test_sort(self):
+        u = self.type2test([1, 0])
+        u.sort()
+        self.assertEqual(u, [0, 1])
+
+        u = self.type2test([2,1,0,-1,-2])
+        u.sort()
+        self.assertEqual(u, self.type2test([-2,-1,0,1,2]))
+
+        self.assertRaises(TypeError, u.sort, 42, 42)
+
+        def revcmp(a, b):
+            return cmp(b, a)
+        u.sort(revcmp)
+        self.assertEqual(u, self.type2test([2,1,0,-1,-2]))
+
+        # The following dumps core in unpatched Python 1.5:
+        def myComparison(x,y):
+            return cmp(x%3, y%7)
+        z = self.type2test(range(12))
+        z.sort(myComparison)
+
+        self.assertRaises(TypeError, z.sort, 2)
+
+        def selfmodifyingComparison(x,y):
+            z.append(1)
+            return cmp(x, y)
+        self.assertRaises(ValueError, z.sort, selfmodifyingComparison)
+
+        self.assertRaises(TypeError, z.sort, lambda x, y: 's')
+
+        self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)
+
+    # XXX: there are currently some slice bugs in Jython
+    def _test_slice(self):
+        u = self.type2test("spam")
+        u[:2] = "h"
+        self.assertEqual(u, list("ham"))
+
+    def test_iadd(self):
+        super(CommonTest, self).test_iadd()
+        u = self.type2test([0, 1])
+        u2 = u
+        u += [2, 3]
+        self.assert_(u is u2)
+
+        u = self.type2test("spam")
+        u += "eggs"
+        self.assertEqual(u, self.type2test("spameggs"))
+
+        self.assertRaises(TypeError, u.__iadd__, None)
+
+    def test_imul(self):
+        u = self.type2test([0, 1])
+        u *= 3
+        self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
+        u *= 0
+        self.assertEqual(u, self.type2test([]))
+        s = self.type2test([])
+        oldid = id(s)
+        s *= 10
+        self.assertEqual(id(s), oldid)
+
+    def test_extendedslicing(self):
+        #  subscript
+        a = self.type2test([0,1,2,3,4])
+
+        #  deletion
+        del a[::2]
+        self.assertEqual(a, self.type2test([1,3]))
+        a = self.type2test(range(5))
+        del a[1::2]
+        self.assertEqual(a, self.type2test([0,2,4]))
+        a = self.type2test(range(5))
+        del a[1::-2]
+        self.assertEqual(a, self.type2test([0,2,3,4]))
+        a = self.type2test(range(10))
+        del a[::1000]
+        self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+        #  assignment
+        a = self.type2test(range(10))
+        a[::2] = [-1]*5
+        self.assertEqual(a, self.type2test([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))
+        a = self.type2test(range(10))
+        a[::-4] = [10]*3
+        self.assertEqual(a, self.type2test([0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
+        a = self.type2test(range(4))
+        a[::-1] = a
+        self.assertEqual(a, self.type2test([3, 2, 1, 0]))
+        a = self.type2test(range(10))
+        b = a[:]
+        c = a[:]
+        a[2:3] = self.type2test(["two", "elements"])
+        b[slice(2,3)] = self.type2test(["two", "elements"])
+        c[2:3:] = self.type2test(["two", "elements"])
+        self.assertEqual(a, b)
+        self.assertEqual(a, c)
+        a = self.type2test(range(10))
+        a[::2] = tuple(range(5))
+        self.assertEqual(a, self.type2test([0, 1, 1, 3, 2, 5, 3, 7, 4, 9]))
+
+    # XXX: CPython specific, PyList doesn't len() during init
+    def _test_constructor_exception_handling(self):
+        # Bug #1242657
+        class F(object):
+            def __iter__(self):
+                yield 23
+            def __len__(self):
+                raise KeyboardInterrupt
+        self.assertRaises(KeyboardInterrupt, list, F())
Index: Lib/test/test_list.py
===================================================================
--- Lib/test/test_list.py	(revision 0)
+++ Lib/test/test_list.py	(revision 0)
@@ -0,0 +1,37 @@
+import unittest
+from test import test_support, list_tests
+
+class ListTest(list_tests.CommonTest):
+    type2test = list
+
+    def test_truth(self):
+        super(ListTest, self).test_truth()
+        self.assert_(not [])
+        self.assert_([42])
+
+    def test_identity(self):
+        self.assert_([] is not [])
+
+    def test_len(self):
+        super(ListTest, self).test_len()
+        self.assertEqual(len([]), 0)
+        self.assertEqual(len([0]), 1)
+        self.assertEqual(len([0, 1, 2]), 3)
+
+def test_main(verbose=None):
+    test_support.run_unittest(ListTest)
+
+    # verify reference counting
+    import sys
+    if verbose and hasattr(sys, "gettotalrefcount"):
+        import gc
+        counts = [None] * 5
+        for i in xrange(len(counts)):
+            test_support.run_unittest(ListTest)
+            gc.collect()
+            counts[i] = sys.gettotalrefcount()
+        print counts
+
+
+if __name__ == "__main__":
+    test_main(verbose=True)