cpython: 4d5417444961 (original) (raw)

--- a/Lib/test/test_xml_etree.py +++ b/Lib/test/test_xml_etree.py @@ -2350,6 +2350,7 @@ class ElementSlicingTest(unittest.TestCa self.assertEqual(e[-2].tag, 'a8') self.assertRaises(IndexError, lambda: e[12])

   self.assertRaises(IndexError, lambda: e[-12])[](#l1.7)

def test_getslice_range(self): e = self._make_elem_with_children(6) @@ -2368,12 +2369,17 @@ class ElementSlicingTest(unittest.TestCa self.assertEqual(self._elem_tags(e[::3]), ['a0', 'a3', 'a6', 'a9']) self.assertEqual(self._elem_tags(e[::8]), ['a0', 'a8']) self.assertEqual(self._elem_tags(e[1::8]), ['a1', 'a9'])

   self.assertEqual(self._elem_tags(e[3::sys.maxsize]), ['a3'])[](#l1.15)

   self.assertEqual(self._elem_tags(e[3::sys.maxsize<<64]), ['a3'])[](#l1.16)

def test_getslice_negative_steps(self): e = self._make_elem_with_children(4) self.assertEqual(self._elem_tags(e[::-1]), ['a3', 'a2', 'a1', 'a0']) self.assertEqual(self._elem_tags(e[::-2]), ['a3', 'a1'])

   self.assertEqual(self._elem_tags(e[3::-sys.maxsize]), ['a3'])[](#l1.23)

   self.assertEqual(self._elem_tags(e[3::-sys.maxsize-1]), ['a3'])[](#l1.24)

   self.assertEqual(self._elem_tags(e[3::-sys.maxsize<<64]), ['a3'])[](#l1.25)

def test_delslice(self): e = self._make_elem_with_children(4) @@ -2400,6 +2406,75 @@ class ElementSlicingTest(unittest.TestCa del e[::2] self.assertEqual(self._subelem_tags(e), ['a1'])

def test_setslice_single_index(self):

   e = self._make_elem_with_children(4)[](#l1.34)

```
   e[1] = ET.Element('b')[](#l1.35)
```

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])[](#l1.36)

```
   e[-2] = ET.Element('c')[](#l1.38)
```

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])[](#l1.39)

   with self.assertRaises(IndexError):[](#l1.41)

```
       e[5] = ET.Element('d')[](#l1.42)
```

   with self.assertRaises(IndexError):[](#l1.43)

       e[-5] = ET.Element('d')[](#l1.44)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'c', 'a3'])[](#l1.45)

def test_setslice_range(self):

   e = self._make_elem_with_children(4)[](#l1.48)

   e[1:3] = [ET.Element('b%s' % i) for i in range(2)][](#l1.49)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'a3'])[](#l1.50)

   e = self._make_elem_with_children(4)[](#l1.52)

```
   e[1:3] = [ET.Element('b')][](#l1.53)
```

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a3'])[](#l1.54)

   e = self._make_elem_with_children(4)[](#l1.56)

   e[1:3] = [ET.Element('b%s' % i) for i in range(3)][](#l1.57)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'b1', 'b2', 'a3'])[](#l1.58)

def test_setslice_steps(self):

   e = self._make_elem_with_children(6)[](#l1.61)

   e[1:5:2] = [ET.Element('b%s' % i) for i in range(2)][](#l1.62)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b0', 'a2', 'b1', 'a4', 'a5'])[](#l1.63)

   e = self._make_elem_with_children(6)[](#l1.65)

   with self.assertRaises(ValueError):[](#l1.66)

       e[1:5:2] = [ET.Element('b')][](#l1.67)

   with self.assertRaises(ValueError):[](#l1.68)

       e[1:5:2] = [ET.Element('b%s' % i) for i in range(3)][](#l1.69)

   with self.assertRaises(ValueError):[](#l1.70)

```
       e[1:5:2] = [][](#l1.71)
```

   self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3', 'a4', 'a5'])[](#l1.72)

   e = self._make_elem_with_children(4)[](#l1.74)

   e[1::sys.maxsize] = [ET.Element('b')][](#l1.75)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])[](#l1.76)

   e[1::sys.maxsize<<64] = [ET.Element('c')][](#l1.77)

   self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])[](#l1.78)

def test_setslice_negative_steps(self):

   e = self._make_elem_with_children(4)[](#l1.81)

   e[2:0:-1] = [ET.Element('b%s' % i) for i in range(2)][](#l1.82)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b1', 'b0', 'a3'])[](#l1.83)

   e = self._make_elem_with_children(4)[](#l1.85)

   with self.assertRaises(ValueError):[](#l1.86)

       e[2:0:-1] = [ET.Element('b')][](#l1.87)

   with self.assertRaises(ValueError):[](#l1.88)

       e[2:0:-1] = [ET.Element('b%s' % i) for i in range(3)][](#l1.89)

   with self.assertRaises(ValueError):[](#l1.90)

```
       e[2:0:-1] = [][](#l1.91)
```

   self.assertEqual(self._subelem_tags(e), ['a0', 'a1', 'a2', 'a3'])[](#l1.92)

   e = self._make_elem_with_children(4)[](#l1.94)

   e[1::-sys.maxsize] = [ET.Element('b')][](#l1.95)

   self.assertEqual(self._subelem_tags(e), ['a0', 'b', 'a2', 'a3'])[](#l1.96)

   e[1::-sys.maxsize-1] = [ET.Element('c')][](#l1.97)

   self.assertEqual(self._subelem_tags(e), ['a0', 'c', 'a2', 'a3'])[](#l1.98)

   e[1::-sys.maxsize<<64] = [ET.Element('d')][](#l1.99)

   self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3'])[](#l1.100)

+ class IOTest(unittest.TestCase): def tearDown(self):

--- a/Modules/_elementtree.c +++ b/Modules/elementtree.c @@ -1711,7 +1711,7 @@ element_ass_subscr(PyObject* self, PyOb Py_ssize_t start, stop, step, slicelen, newlen, cur, i; PyObject* recycle = NULL;

```
   PyObject* seq = NULL;[](#l2.7)
```

```
   PyObject* seq;[](#l2.8)
```

if (!self->extra) { if (create_extra(self, NULL) < 0) @@ -1790,21 +1790,21 @@ element_ass_subscr(PyObject* self_, PyOb Py_XDECREF(recycle); return 0; }

```
   else {[](#l2.16)
```

       /* A new slice is actually being assigned */[](#l2.17)

       seq = PySequence_Fast(value, "");[](#l2.18)

```
       if (!seq) {[](#l2.19)
```
```
           PyErr_Format([](#l2.20)
```

               PyExc_TypeError,[](#l2.21)

               "expected sequence, not \"%.200s\"", Py_TYPE(value)->tp_name[](#l2.22)

```
               );[](#l2.23)
```
```
           return -1;[](#l2.24)
```
```
       }[](#l2.25)
```

       newlen = PySequence_Size(seq);[](#l2.26)

   /* A new slice is actually being assigned */[](#l2.28)

   seq = PySequence_Fast(value, "");[](#l2.29)

```
   if (!seq) {[](#l2.30)
```
```
       PyErr_Format([](#l2.31)
```
```
           PyExc_TypeError,[](#l2.32)
```

           "expected sequence, not \"%.200s\"", Py_TYPE(value)->tp_name[](#l2.33)

```
           );[](#l2.34)
```

       return -1;[](#l2.35)
   }[](#l2.36)

   newlen = PySequence_Size(seq);[](#l2.37)

if (step != 1 && newlen != slicelen) {

       Py_DECREF(seq);[](#l2.41)
       PyErr_Format(PyExc_ValueError,[](#l2.42)
           "attempt to assign sequence of size %zd "[](#l2.43)
           "to extended slice of size %zd",[](#l2.44)

@@ -1816,9 +1816,7 @@ element_ass_subscr(PyObject* self_, PyOb /* Resize before creating the recycle bin, to prevent refleaks. */ if (newlen > slicelen) { if (element_resize(self, newlen - slicelen) < 0) {

```
           if (seq) {[](#l2.49)
```

               Py_DECREF(seq);[](#l2.50)

```
           }[](#l2.51)
```

           Py_DECREF(seq);[](#l2.52)
           return -1;[](#l2.53)
       }[](#l2.54)
   }[](#l2.55)

@@ -1829,9 +1827,7 @@ element_ass_subscr(PyObject* self_, PyOb we're done modifying the element */ recycle = PyList_New(slicelen); if (!recycle) {

```
           if (seq) {[](#l2.60)
```

               Py_DECREF(seq);[](#l2.61)

```
           }[](#l2.62)
```

           Py_DECREF(seq);[](#l2.63)
           return -1;[](#l2.64)
       }[](#l2.65)
       for (cur = start, i = 0; i < slicelen;[](#l2.66)

@@ -1859,9 +1855,7 @@ element_ass_subscr(PyObject* self_, PyOb self->extra->length += newlen - slicelen;

```
   if (seq) {[](#l2.71)
```
```
       Py_DECREF(seq);[](#l2.72)
```
```
   }[](#l2.73)
```

```
   Py_DECREF(seq);[](#l2.74)
```

/* discard the recycle bin, and everything in it */ Py_XDECREF(recycle);