Fixed the incorrect behavior of the * and *= operators

Details:

* Fixed the incorrect behavior of the `*` and `*=` operators to now validate
  that the number is an integer and raise TypeError otherwise, consistent with
  the built-in list class. (See issue #27)

* The `*=` operator now modifies the left hand operand list in place, instead of
  returning a new list. Note that both is correct behavior. (Part of issue #27)

Signed-off-by: Andreas Maier <andreas.r.maier@gmx.de>

Author: andy-maier

docs/changes.rst

@@ -21,6 +21,10 @@ Released: not yet
   (incorrectly) as a single item. For '+', the right hand operand now must
   be a list, consistent with the built-in list class. (See issue #25)
 
+* Fixed the incorrect behavior of the `*` and `*=` operators to now validate
+  that the number is an integer and raise TypeError otherwise, consistent with
+  the built-in list class. (See issue #27)
+
 **Enhancements:**
 
 * Test: Coveralls now runs on all python versions, merging the result.
@@ -46,9 +50,14 @@ Released: not yet
   list class as of Python 3.8, including all methods that have been added since
   Python 2.7, on all Python versions.
 
+<<<<<<< HEAD
 * Improved the performance of initializing a NocaseList object by copying
   the internal lower-cased list when possible, instead of rebuilding it from
   the original list.
+=======
+* The `*=` operator now modifies the left hand operand list in place, instead of
+  returning a new list. Note that both is correct behavior. (Part of issue #27)
+>>>>>>> 76dc790... Fixed the incorrect behavior of the `*` and `*=` operators
 
 **Cleanup:**
 

nocaselist/_nocaselist.py

@@ -4,8 +4,16 @@
 
 from __future__ import print_function, absolute_import
 
+import sys
+
 __all__ = ['NocaseList']
 
+if sys.version_info[0] == 2:
+    # pylint: disable=undefined-variable
+    _INTEGER_TYPES = (long, int)  # noqa: F821
+else:
+    _INTEGER_TYPES = (int,)
+
 
 def _lc_list(lst):
     """
@@ -154,22 +162,34 @@ def __iadd__(self, other):
 
     def __mul__(self, number):
         """
-        Return a shallow copy of the list, that has the items from the original
-        list as many times as specified by number (including 0). The original
-        list is not changed.
+        Return a new :class:`NocaseList` object that contains the items from
+        the left hand operand (``self``) as many times as specified by the right
+        hand operand (``number``).
+
+        A number <= 0 causes the returned list to be empty.
+
+        The left hand operand (``self``) is not changed.
 
         Invoked using ``ncl * number``.
         """
+        if not isinstance(number, _INTEGER_TYPES):
+            raise TypeError(
+                "Cannot multiply NocaseList by non-integer of type {t}".
+                format(t=type(number)))
         lst = NocaseList()
         for _ in range(0, number):
             lst.extend(self)
         return lst
 
     def __rmul__(self, number):
         """
-        Return a shallow copy of the list, that has the items from the original
-        list as many times as specified by number (including 0). The original
-        list is not changed.
+        Return a new :class:`NocaseList` object that contains the items from
+        the right hand operand (``self``) as many times as specified by the left
+        hand operand (``number``).
+
+        A number <= 0 causes the returned list to be empty.
+
+        The right hand operand (``self``) is not changed.
 
         Invoked using ``number * ncl``.
         """
@@ -178,15 +198,28 @@ def __rmul__(self, number):
 
     def __imul__(self, number):
         """
-        Replace the original list by a list that has the items from the original
-        list as many times as specified by number (including 0).
+        Change the left hand operand (``self``) so that it contains the items
+        from the original left hand operand (``self``) as many times as
+        specified by the right hand operand (``number``).
+
+        A number <= 0 will empty the left hand operand.
 
         Invoked using ``ncl *= number``.
         """
         # Note: It is unusual that the method has to return self, but it was
         # verified that this is necessary.
-        lst = self * number  # Delegates to __mul__()
-        return lst
+        if not isinstance(number, _INTEGER_TYPES):
+            raise TypeError(
+                "Cannot multiply NocaseList by non-integer of type {t}".
+                format(t=type(number)))
+        if number <= 0:
+            del self[:]
+            del self._lc_list[:]
+        else:
+            self_items = list(self)
+            for _ in range(0, number - 1):
+                self.extend(self_items)
+        return self
 
     def __reversed__(self):
         """

tests/unittest/test_nocaselist.py

@@ -1181,6 +1181,24 @@ def test_NocaseList_iadd(testcase, nclist, other, exp_result):
         ),
         None, None, True
     ),
+    (
+        "Empty list times -0.5 (must be integer)",
+        dict(
+            nclist=NocaseList(),
+            number=-0.5,
+            exp_result=NocaseList(),
+        ),
+        TypeError, None, True
+    ),
+    (
+        "Empty list times +0.5 (must be integer)",
+        dict(
+            nclist=NocaseList(),
+            number=+0.5,
+            exp_result=NocaseList(),
+        ),
+        TypeError, None, True
+    ),
     (
         "List with two items times -1",
         dict(
@@ -1279,6 +1297,7 @@ def test_NocaseList_imul(testcase, nclist, number, exp_result):
 
     # Don't change the testcase data, but a copy
     nclist_copy = NocaseList(nclist)
+    nclist_copy_id = id(nclist_copy)
 
     # The code to be tested
     nclist_copy *= number
@@ -1287,6 +1306,9 @@ def test_NocaseList_imul(testcase, nclist, number, exp_result):
     # are not mistaken as expected exceptions
     assert testcase.exp_exc_types is None
 
+    # Verify the object has been changed in place
+    assert id(nclist_copy) == nclist_copy_id
+
     assert_equal(nclist_copy, exp_result)