From a3b045c17e493fd3b8398c7ea69f96bbe180010f Mon Sep 17 00:00:00 2001
From: MomIsBestFriend <>
Date: Fri, 17 Jan 2020 17:09:29 +0200
Subject: [PATCH 1/4] Refactored "test_binop_other"

---
 pandas/tests/internals/test_internals.py | 138 ++++++++++++++++-------
 1 file changed, 96 insertions(+), 42 deletions(-)

diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 15b1434f8629f..5ad5bb4b62236 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1164,63 +1164,117 @@ def any(self, axis=None):
 
 
 class TestCanHoldElement:
-    @pytest.mark.parametrize(
-        "value, dtype",
-        [
-            (1, "i8"),
-            (1.0, "f8"),
-            (2 ** 63, "f8"),
-            (1j, "complex128"),
-            (2 ** 63, "complex128"),
-            (True, "bool"),
-            (np.timedelta64(20, "ns"), "<m8[ns]"),
-            (np.datetime64(20, "ns"), "<M8[ns]"),
-        ],
-    )
-    @pytest.mark.parametrize(
+
+    ops = pytest.mark.parametrize(
         "op",
         [
             operator.add,
-            operator.sub,
-            operator.mul,
-            operator.truediv,
             operator.mod,
+            operator.mul,
             operator.pow,
+            operator.sub,
+            operator.truediv,
         ],
         ids=lambda x: x.__name__,
     )
-    def test_binop_other(self, op, value, dtype):
-        skip = {
-            (operator.add, "bool"),
-            (operator.sub, "bool"),
-            (operator.mul, "bool"),
-            (operator.truediv, "bool"),
-            (operator.mod, "i8"),
-            (operator.mod, "complex128"),
-            (operator.pow, "bool"),
-        }
-        if (op, dtype) in skip:
-            pytest.skip("Invalid combination {},{}".format(op, dtype))
+
+    @ops
+    @pytest.mark.parametrize("value", [True])
+    def test_binop_bool(self, op, value):
+        dtype = "bool"
+
+        if op in [
+            operator.add,
+            operator.mul,
+            operator.pow,
+            operator.sub,
+            operator.truediv,
+        ]:
+            pytest.skip(f"Invalid combination {op},{dtype}")
+
+        e = DummyElement(value, dtype)
+        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+
+        result = op(s, e.value).dtypes
+        expected = op(s, value).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @ops
+    @pytest.mark.parametrize("value", [1j, 2 ** 63])
+    def test_binop_complex128(self, op, value):
+        dtype = "complex128"
+
+        if op == operator.mod:
+            pytest.skip(f"Invalid combination {op},{dtype}")
+
+        e = DummyElement(value, dtype)
+        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+
+        result = op(s, e.value).dtypes
+        expected = op(s, value).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @ops
+    @pytest.mark.parametrize("value", [1.0, 2 ** 63])
+    def test_binop_f8(self, op, value):
+        dtype = "f8"
 
         e = DummyElement(value, dtype)
         s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
 
-        invalid = {
-            (operator.pow, "<M8[ns]"),
-            (operator.mod, "<M8[ns]"),
-            (operator.truediv, "<M8[ns]"),
-            (operator.mul, "<M8[ns]"),
-            (operator.add, "<M8[ns]"),
-            (operator.pow, "<m8[ns]"),
-            (operator.mul, "<m8[ns]"),
-        }
-
-        if (op, dtype) in invalid:
+        result = op(s, e.value).dtypes
+        expected = op(s, value).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @ops
+    @pytest.mark.parametrize("value", [1])
+    def test_binop_i8(self, op, value):
+        dtype = "i8"
+
+        if op == operator.mod:
+            pytest.skip(f"Invalid combination {op},{dtype}")
+
+        e = DummyElement(value, dtype)
+        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+
+        result = op(s, e.value).dtypes
+        expected = op(s, value).dtypes
+        tm.assert_series_equal(result, expected)
+
+    @ops
+    @pytest.mark.parametrize("value", [np.timedelta64(20, "ns")])
+    def test_binop_m(self, op, value):
+        dtype = "<m8[ns]"
+
+        e = DummyElement(value, dtype)
+        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+
+        if op in [operator.mul, operator.pow]:
+            with pytest.raises(TypeError):
+                op(s, e.value)
+        else:
+            result = op(s, e.value).dtypes
+            expected = op(s, value).dtypes
+            tm.assert_series_equal(result, expected)
+
+    @ops
+    @pytest.mark.parametrize("value", [np.datetime64(20, "ns")])
+    def test_binop_m_capitalized(self, op, value):
+        dtype = "<M8[ns]"
+
+        e = DummyElement(value, dtype)
+        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
+
+        if op in [
+            operator.add,
+            operator.mod,
+            operator.mul,
+            operator.pow,
+            operator.truediv,
+        ]:
             with pytest.raises(TypeError):
                 op(s, e.value)
         else:
-            # FIXME: Since dispatching to Series, this test no longer
-            # asserts anything meaningful
             result = op(s, e.value).dtypes
             expected = op(s, value).dtypes
             tm.assert_series_equal(result, expected)

From c4f5f1d1fc30f5c9066743cd1d6ab33a2486c4c2 Mon Sep 17 00:00:00 2001
From: MomIsBestFriend <>
Date: Fri, 17 Jan 2020 17:10:19 +0200
Subject: [PATCH 2/4] Fixed some bare pytest raises

---
 pandas/tests/internals/test_internals.py | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 5ad5bb4b62236..537a3cb2bad89 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1250,7 +1250,16 @@ def test_binop_m(self, op, value):
         s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
 
         if op in [operator.mul, operator.pow]:
-            with pytest.raises(TypeError):
+            # operator.mul will raise an external error message.
+            msg = (
+                None
+                if op == operator.mul
+                else (
+                    f"cannot perform __{op.__name__}__ "
+                    "with this index type: TimedeltaArray"
+                )
+            )
+            with pytest.raises(TypeError, match=msg):
                 op(s, e.value)
         else:
             result = op(s, e.value).dtypes
@@ -1272,7 +1281,16 @@ def test_binop_m_capitalized(self, op, value):
             operator.pow,
             operator.truediv,
         ]:
-            with pytest.raises(TypeError):
+            # operator.add will raise an external error message.
+            msg = (
+                None
+                if op == operator.add
+                else (
+                    f"cannot perform __{op.__name__}__ "
+                    "with this index type: DatetimeArray"
+                )
+            )
+            with pytest.raises(TypeError, match=msg):
                 op(s, e.value)
         else:
             result = op(s, e.value).dtypes

From d920cdd6888ed129ce6fc55e3c6f67fdaab80bca Mon Sep 17 00:00:00 2001
From: MomIsBestFriend <>
Date: Fri, 17 Jan 2020 21:58:52 +0200
Subject: [PATCH 3/4] Revert to original, added if statement

---
 pandas/tests/internals/test_internals.py | 152 +++++++----------------
 1 file changed, 45 insertions(+), 107 deletions(-)

diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 537a3cb2bad89..458a937ae1005 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1164,135 +1164,73 @@ def any(self, axis=None):
 
 
 class TestCanHoldElement:
-
-    ops = pytest.mark.parametrize(
+    @pytest.mark.parametrize(
         "op",
         [
             operator.add,
-            operator.mod,
-            operator.mul,
-            operator.pow,
             operator.sub,
+            operator.mul,
             operator.truediv,
+            operator.mod,
+            operator.pow,
         ],
         ids=lambda x: x.__name__,
     )
-
-    @ops
-    @pytest.mark.parametrize("value", [True])
-    def test_binop_bool(self, op, value):
-        dtype = "bool"
-
-        if op in [
-            operator.add,
-            operator.mul,
-            operator.pow,
-            operator.sub,
-            operator.truediv,
-        ]:
-            pytest.skip(f"Invalid combination {op},{dtype}")
-
-        e = DummyElement(value, dtype)
-        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
-
-        result = op(s, e.value).dtypes
-        expected = op(s, value).dtypes
-        tm.assert_series_equal(result, expected)
-
-    @ops
-    @pytest.mark.parametrize("value", [1j, 2 ** 63])
-    def test_binop_complex128(self, op, value):
-        dtype = "complex128"
-
-        if op == operator.mod:
-            pytest.skip(f"Invalid combination {op},{dtype}")
-
-        e = DummyElement(value, dtype)
-        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
-
-        result = op(s, e.value).dtypes
-        expected = op(s, value).dtypes
-        tm.assert_series_equal(result, expected)
-
-    @ops
-    @pytest.mark.parametrize("value", [1.0, 2 ** 63])
-    def test_binop_f8(self, op, value):
-        dtype = "f8"
-
-        e = DummyElement(value, dtype)
-        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
-
-        result = op(s, e.value).dtypes
-        expected = op(s, value).dtypes
-        tm.assert_series_equal(result, expected)
-
-    @ops
-    @pytest.mark.parametrize("value", [1])
-    def test_binop_i8(self, op, value):
-        dtype = "i8"
-
-        if op == operator.mod:
+    @pytest.mark.parametrize(
+        "value, dtype",
+        [
+            (1, "i8"),
+            (1.0, "f8"),
+            (2 ** 63, "f8"),
+            (1j, "complex128"),
+            (2 ** 63, "complex128"),
+            (True, "bool"),
+            (np.timedelta64(20, "ns"), "<m8[ns]"),
+            (np.datetime64(20, "ns"), "<M8[ns]"),
+        ],
+    )
+    def test_binop_other(self, op, value, dtype):
+        skip = {
+            (operator.add, "bool"),
+            (operator.sub, "bool"),
+            (operator.mul, "bool"),
+            (operator.truediv, "bool"),
+            (operator.mod, "i8"),
+            (operator.mod, "complex128"),
+            (operator.pow, "bool"),
+        }
+        if (op, dtype) in skip:
             pytest.skip(f"Invalid combination {op},{dtype}")
 
         e = DummyElement(value, dtype)
         s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
 
-        result = op(s, e.value).dtypes
-        expected = op(s, value).dtypes
-        tm.assert_series_equal(result, expected)
-
-    @ops
-    @pytest.mark.parametrize("value", [np.timedelta64(20, "ns")])
-    def test_binop_m(self, op, value):
-        dtype = "<m8[ns]"
-
-        e = DummyElement(value, dtype)
-        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
-
-        if op in [operator.mul, operator.pow]:
-            # operator.mul will raise an external error message.
+        invalid = {
+            (operator.pow, "<M8[ns]"),
+            (operator.mod, "<M8[ns]"),
+            (operator.truediv, "<M8[ns]"),
+            (operator.mul, "<M8[ns]"),
+            (operator.add, "<M8[ns]"),
+            (operator.pow, "<m8[ns]"),
+            (operator.mul, "<m8[ns]"),
+        }
+
+        if (op, dtype) in invalid:
             msg = (
                 None
-                if op == operator.mul
+                if (dtype == "<M8[ns]" and op == operator.add)
+                or (dtype == "<m8[ns]" and op == operator.mul)
                 else (
-                    f"cannot perform __{op.__name__}__ "
-                    "with this index type: TimedeltaArray"
+                    f"cannot perform __{op.__name__}__ with this "
+                    "index type: (DatetimeArray|TimedeltaArray)"
                 )
             )
-            with pytest.raises(TypeError, match=msg):
-                op(s, e.value)
-        else:
-            result = op(s, e.value).dtypes
-            expected = op(s, value).dtypes
-            tm.assert_series_equal(result, expected)
-
-    @ops
-    @pytest.mark.parametrize("value", [np.datetime64(20, "ns")])
-    def test_binop_m_capitalized(self, op, value):
-        dtype = "<M8[ns]"
-
-        e = DummyElement(value, dtype)
-        s = pd.DataFrame({"A": [e.value, e.value]}, dtype=e.dtype)
 
-        if op in [
-            operator.add,
-            operator.mod,
-            operator.mul,
-            operator.pow,
-            operator.truediv,
-        ]:
-            # operator.add will raise an external error message.
-            msg = (
-                None
-                if op == operator.add
-                else (
-                    f"cannot perform __{op.__name__}__ "
-                    "with this index type: DatetimeArray"
-                )
-            )
             with pytest.raises(TypeError, match=msg):
                 op(s, e.value)
         else:
+            # FIXME: Since dispatching to Series, this test no longer
+            # asserts anything meaningful
             result = op(s, e.value).dtypes
             expected = op(s, value).dtypes
             tm.assert_series_equal(result, expected)

From 93b318e8b695d267f0b04d13d76bfbe86bebee0d Mon Sep 17 00:00:00 2001
From: MomIsBestFriend <50263213+MomIsBestFriend@users.noreply.github.com>
Date: Sat, 18 Jan 2020 00:35:24 +0200
Subject: [PATCH 4/4] Update test_internals.py

---
 pandas/tests/internals/test_internals.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 458a937ae1005..9c1442b75fbb2 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -1164,18 +1164,6 @@ def any(self, axis=None):
 
 
 class TestCanHoldElement:
-    @pytest.mark.parametrize(
-        "op",
-        [
-            operator.add,
-            operator.sub,
-            operator.mul,
-            operator.truediv,
-            operator.mod,
-            operator.pow,
-        ],
-        ids=lambda x: x.__name__,
-    )
     @pytest.mark.parametrize(
         "value, dtype",
         [
@@ -1189,6 +1177,18 @@ class TestCanHoldElement:
             (np.datetime64(20, "ns"), "<M8[ns]"),
         ],
     )
+    @pytest.mark.parametrize(
+        "op",
+        [
+            operator.add,
+            operator.sub,
+            operator.mul,
+            operator.truediv,
+            operator.mod,
+            operator.pow,
+        ],
+        ids=lambda x: x.__name__,
+    )
     def test_binop_other(self, op, value, dtype):
         skip = {
             (operator.add, "bool"),