CLN: no need for mixin, move non-index timedelta arithmetic test

pandas/tests/indexes/test_frozen.py

@@ -5,14 +5,20 @@
 from pandas.core.indexes.frozen import FrozenList
 
 
-class CheckImmutableMixin:
-    mutable_regex = re.compile("does not support mutable operations")
+class TestFrozenList:
+
+    unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])
+
+    def setup_method(self, _):
+        self.lst = [1, 2, 3, 4, 5]
+        self.container = FrozenList(self.lst)
 
     def check_mutable_error(self, *args, **kwargs):
         # Pass whatever function you normally would to pytest.raises
         # (after the Exception kind).
+        mutable_regex = re.compile("does not support mutable operations")
         with pytest.raises(TypeError):
-            self.mutable_regex(*args, **kwargs)
+            mutable_regex(*args, **kwargs)
 
     def test_no_mutable_funcs(self):
         def setitem():
@@ -34,7 +40,8 @@ def delslice():
             del self.container[0:3]
 
         self.check_mutable_error(delslice)
-        mutable_methods = getattr(self, "mutable_methods", [])
+
+        mutable_methods = ("extend", "pop", "remove", "insert")
 
         for meth in mutable_methods:
             self.check_mutable_error(getattr(self.container, meth))
@@ -44,34 +51,19 @@ def test_slicing_maintains_type(self):
         expected = self.lst[1:2]
         self.check_result(result, expected)
 
-    def check_result(self, result, expected, klass=None):
-        klass = klass or self.klass
-        assert isinstance(result, klass)
+    def check_result(self, result, expected):
+        assert isinstance(result, FrozenList)
         assert result == expected
 
-
-class CheckStringMixin:
     def test_string_methods_dont_fail(self):
         repr(self.container)
         str(self.container)
         bytes(self.container)
 
     def test_tricky_container(self):
-        if not hasattr(self, "unicode_container"):
-            pytest.skip("Need unicode_container to test with this")
         repr(self.unicode_container)
         str(self.unicode_container)
 
-
-class TestFrozenList(CheckImmutableMixin, CheckStringMixin):
-    mutable_methods = ("extend", "pop", "remove", "insert")
-    unicode_container = FrozenList(["\u05d0", "\u05d1", "c"])
-
-    def setup_method(self, _):
-        self.lst = [1, 2, 3, 4, 5]
-        self.container = FrozenList(self.lst)
-        self.klass = FrozenList
-
     def test_add(self):
         result = self.container + (1, 2, 3)
         expected = FrozenList(self.lst + [1, 2, 3])

pandas/tests/indexes/timedeltas/test_arithmetic.py

@@ -173,57 +173,6 @@ def test_tdi_isub_timedeltalike(self, delta):
 
     # -------------------------------------------------------------
 
-    # TODO: after #24365 this probably belongs in scalar tests
-    def test_ops_ndarray(self):
-        td = Timedelta("1 day")
-
-        # timedelta, timedelta
-        other = pd.to_timedelta(["1 day"]).values
-        expected = pd.to_timedelta(["2 days"]).values
-        tm.assert_numpy_array_equal(td + other, expected)
-        tm.assert_numpy_array_equal(other + td, expected)
-        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
-        with pytest.raises(TypeError, match=msg):
-            td + np.array([1])
-        msg = r"unsupported operand type\(s\) for \+: 'numpy.ndarray' and 'Timedelta'"
-        with pytest.raises(TypeError, match=msg):
-            np.array([1]) + td
-
-        expected = pd.to_timedelta(["0 days"]).values
-        tm.assert_numpy_array_equal(td - other, expected)
-        tm.assert_numpy_array_equal(-other + td, expected)
-        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
-        with pytest.raises(TypeError, match=msg):
-            td - np.array([1])
-        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
-        with pytest.raises(TypeError, match=msg):
-            np.array([1]) - td
-
-        expected = pd.to_timedelta(["2 days"]).values
-        tm.assert_numpy_array_equal(td * np.array([2]), expected)
-        tm.assert_numpy_array_equal(np.array([2]) * td, expected)
-        msg = (
-            "ufunc '?multiply'? cannot use operands with types"
-            r" dtype\('<m8\[ns\]'\) and dtype\('<m8\[ns\]'\)"
-        )
-        with pytest.raises(TypeError, match=msg):
-            td * other
-        with pytest.raises(TypeError, match=msg):
-            other * td
-
-        tm.assert_numpy_array_equal(td / other, np.array([1], dtype=np.float64))
-        tm.assert_numpy_array_equal(other / td, np.array([1], dtype=np.float64))
-
-        # timedelta, datetime
-        other = pd.to_datetime(["2000-01-01"]).values
-        expected = pd.to_datetime(["2000-01-02"]).values
-        tm.assert_numpy_array_equal(td + other, expected)
-        tm.assert_numpy_array_equal(other + td, expected)
-
-        expected = pd.to_datetime(["1999-12-31"]).values
-        tm.assert_numpy_array_equal(-td + other, expected)
-        tm.assert_numpy_array_equal(other - td, expected)
-
     def test_tdi_ops_attributes(self):
         rng = timedelta_range("2 days", periods=5, freq="2D", name="x")
 

pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -241,6 +241,57 @@ def test_td_add_mixed_timedeltalike_object_dtype_array(self, op):
         res = op(arr, Timedelta("1D"))
         tm.assert_numpy_array_equal(res, exp)
 
+    # TODO: moved from index tests following #24365, may need de-duplication
+    def test_ops_ndarray(self):
+        td = Timedelta("1 day")
+
+        # timedelta, timedelta
+        other = pd.to_timedelta(["1 day"]).values
+        expected = pd.to_timedelta(["2 days"]).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+        msg = r"unsupported operand type\(s\) for \+: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td + np.array([1])
+        msg = r"unsupported operand type\(s\) for \+: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.array([1]) + td
+
+        expected = pd.to_timedelta(["0 days"]).values
+        tm.assert_numpy_array_equal(td - other, expected)
+        tm.assert_numpy_array_equal(-other + td, expected)
+        msg = r"unsupported operand type\(s\) for -: 'Timedelta' and 'int'"
+        with pytest.raises(TypeError, match=msg):
+            td - np.array([1])
+        msg = r"unsupported operand type\(s\) for -: 'numpy.ndarray' and 'Timedelta'"
+        with pytest.raises(TypeError, match=msg):
+            np.array([1]) - td
+
+        expected = pd.to_timedelta(["2 days"]).values
+        tm.assert_numpy_array_equal(td * np.array([2]), expected)
+        tm.assert_numpy_array_equal(np.array([2]) * td, expected)
+        msg = (
+            "ufunc '?multiply'? cannot use operands with types"
+            r" dtype\('<m8\[ns\]'\) and dtype\('<m8\[ns\]'\)"
+        )
+        with pytest.raises(TypeError, match=msg):
+            td * other
+        with pytest.raises(TypeError, match=msg):
+            other * td
+
+        tm.assert_numpy_array_equal(td / other, np.array([1], dtype=np.float64))
+        tm.assert_numpy_array_equal(other / td, np.array([1], dtype=np.float64))
+
+        # timedelta, datetime
+        other = pd.to_datetime(["2000-01-01"]).values
+        expected = pd.to_datetime(["2000-01-02"]).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+
+        expected = pd.to_datetime(["1999-12-31"]).values
+        tm.assert_numpy_array_equal(-td + other, expected)
+        tm.assert_numpy_array_equal(other - td, expected)
+
 
 class TestTimedeltaMultiplicationDivision:
     """