TST: collect unary tests

pandas/tests/frame/test_operators.py

@@ -1,131 +1,13 @@
-from decimal import Decimal
 import operator
 import re
 
 import numpy as np
 import pytest
 
-import pandas as pd
 from pandas import DataFrame, Series
 import pandas._testing as tm
 
 
-class TestDataFrameUnaryOperators:
-    # __pos__, __neg__, __inv__
-
-    @pytest.mark.parametrize(
-        "df,expected",
-        [
-            (pd.DataFrame({"a": [-1, 1]}), pd.DataFrame({"a": [1, -1]})),
-            (pd.DataFrame({"a": [False, True]}), pd.DataFrame({"a": [True, False]})),
-            (
-                pd.DataFrame({"a": pd.Series(pd.to_timedelta([-1, 1]))}),
-                pd.DataFrame({"a": pd.Series(pd.to_timedelta([1, -1]))}),
-            ),
-        ],
-    )
-    def test_neg_numeric(self, df, expected):
-        tm.assert_frame_equal(-df, expected)
-        tm.assert_series_equal(-df["a"], expected["a"])
-
-    @pytest.mark.parametrize(
-        "df, expected",
-        [
-            (np.array([1, 2], dtype=object), np.array([-1, -2], dtype=object)),
-            ([Decimal("1.0"), Decimal("2.0")], [Decimal("-1.0"), Decimal("-2.0")]),
-        ],
-    )
-    def test_neg_object(self, df, expected):
-        # GH#21380
-        df = pd.DataFrame({"a": df})
-        expected = pd.DataFrame({"a": expected})
-        tm.assert_frame_equal(-df, expected)
-        tm.assert_series_equal(-df["a"], expected["a"])
-
-    @pytest.mark.parametrize(
-        "df",
-        [
-            pd.DataFrame({"a": ["a", "b"]}),
-            pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])}),
-        ],
-    )
-    def test_neg_raises(self, df):
-        msg = (
-            "bad operand type for unary -: 'str'|"
-            r"Unary negative expects numeric dtype, not datetime64\[ns\]"
-        )
-        with pytest.raises(TypeError, match=msg):
-            (-df)
-        with pytest.raises(TypeError, match=msg):
-            (-df["a"])
-
-    def test_invert(self, float_frame):
-        df = float_frame
-
-        tm.assert_frame_equal(-(df < 0), ~(df < 0))
-
-    def test_invert_mixed(self):
-        shape = (10, 5)
-        df = pd.concat(
-            [
-                pd.DataFrame(np.zeros(shape, dtype="bool")),
-                pd.DataFrame(np.zeros(shape, dtype=int)),
-            ],
-            axis=1,
-            ignore_index=True,
-        )
-        result = ~df
-        expected = pd.concat(
-            [
-                pd.DataFrame(np.ones(shape, dtype="bool")),
-                pd.DataFrame(-np.ones(shape, dtype=int)),
-            ],
-            axis=1,
-            ignore_index=True,
-        )
-        tm.assert_frame_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "df",
-        [
-            pd.DataFrame({"a": [-1, 1]}),
-            pd.DataFrame({"a": [False, True]}),
-            pd.DataFrame({"a": pd.Series(pd.to_timedelta([-1, 1]))}),
-        ],
-    )
-    def test_pos_numeric(self, df):
-        # GH#16073
-        tm.assert_frame_equal(+df, df)
-        tm.assert_series_equal(+df["a"], df["a"])
-
-    @pytest.mark.parametrize(
-        "df",
-        [
-            # numpy changing behavior in the future
-            pytest.param(
-                pd.DataFrame({"a": ["a", "b"]}),
-                marks=[pytest.mark.filterwarnings("ignore")],
-            ),
-            pd.DataFrame({"a": np.array([-1, 2], dtype=object)}),
-            pd.DataFrame({"a": [Decimal("-1.0"), Decimal("2.0")]}),
-        ],
-    )
-    def test_pos_object(self, df):
-        # GH#21380
-        tm.assert_frame_equal(+df, df)
-        tm.assert_series_equal(+df["a"], df["a"])
-
-    @pytest.mark.parametrize(
-        "df", [pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])})]
-    )
-    def test_pos_raises(self, df):
-        msg = "Unary plus expects .* dtype, not datetime64\\[ns\\]"
-        with pytest.raises(TypeError, match=msg):
-            (+df)
-        with pytest.raises(TypeError, match=msg):
-            (+df["a"])
-
-
 class TestDataFrameLogicalOperators:
     # &, |, ^
 

pandas/tests/frame/test_unary.py

@@ -0,0 +1,123 @@
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestDataFrameUnaryOperators:
+    # __pos__, __neg__, __inv__
+
+    @pytest.mark.parametrize(
+        "df,expected",
+        [
+            (pd.DataFrame({"a": [-1, 1]}), pd.DataFrame({"a": [1, -1]})),
+            (pd.DataFrame({"a": [False, True]}), pd.DataFrame({"a": [True, False]})),
+            (
+                pd.DataFrame({"a": pd.Series(pd.to_timedelta([-1, 1]))}),
+                pd.DataFrame({"a": pd.Series(pd.to_timedelta([1, -1]))}),
+            ),
+        ],
+    )
+    def test_neg_numeric(self, df, expected):
+        tm.assert_frame_equal(-df, expected)
+        tm.assert_series_equal(-df["a"], expected["a"])
+
+    @pytest.mark.parametrize(
+        "df, expected",
+        [
+            (np.array([1, 2], dtype=object), np.array([-1, -2], dtype=object)),
+            ([Decimal("1.0"), Decimal("2.0")], [Decimal("-1.0"), Decimal("-2.0")]),
+        ],
+    )
+    def test_neg_object(self, df, expected):
+        # GH#21380
+        df = pd.DataFrame({"a": df})
+        expected = pd.DataFrame({"a": expected})
+        tm.assert_frame_equal(-df, expected)
+        tm.assert_series_equal(-df["a"], expected["a"])
+
+    @pytest.mark.parametrize(
+        "df",
+        [
+            pd.DataFrame({"a": ["a", "b"]}),
+            pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])}),
+        ],
+    )
+    def test_neg_raises(self, df):
+        msg = (
+            "bad operand type for unary -: 'str'|"
+            r"Unary negative expects numeric dtype, not datetime64\[ns\]"
+        )
+        with pytest.raises(TypeError, match=msg):
+            (-df)
+        with pytest.raises(TypeError, match=msg):
+            (-df["a"])
+
+    def test_invert(self, float_frame):
+        df = float_frame
+
+        tm.assert_frame_equal(-(df < 0), ~(df < 0))
+
+    def test_invert_mixed(self):
+        shape = (10, 5)
+        df = pd.concat(
+            [
+                pd.DataFrame(np.zeros(shape, dtype="bool")),
+                pd.DataFrame(np.zeros(shape, dtype=int)),
+            ],
+            axis=1,
+            ignore_index=True,
+        )
+        result = ~df
+        expected = pd.concat(
+            [
+                pd.DataFrame(np.ones(shape, dtype="bool")),
+                pd.DataFrame(-np.ones(shape, dtype=int)),
+            ],
+            axis=1,
+            ignore_index=True,
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "df",
+        [
+            pd.DataFrame({"a": [-1, 1]}),
+            pd.DataFrame({"a": [False, True]}),
+            pd.DataFrame({"a": pd.Series(pd.to_timedelta([-1, 1]))}),
+        ],
+    )
+    def test_pos_numeric(self, df):
+        # GH#16073
+        tm.assert_frame_equal(+df, df)
+        tm.assert_series_equal(+df["a"], df["a"])
+
+    @pytest.mark.parametrize(
+        "df",
+        [
+            # numpy changing behavior in the future
+            pytest.param(
+                pd.DataFrame({"a": ["a", "b"]}),
+                marks=[pytest.mark.filterwarnings("ignore")],
+            ),
+            pd.DataFrame({"a": np.array([-1, 2], dtype=object)}),
+            pd.DataFrame({"a": [Decimal("-1.0"), Decimal("2.0")]}),
+        ],
+    )
+    def test_pos_object(self, df):
+        # GH#21380
+        tm.assert_frame_equal(+df, df)
+        tm.assert_series_equal(+df["a"], df["a"])
+
+    @pytest.mark.parametrize(
+        "df", [pd.DataFrame({"a": pd.to_datetime(["2017-01-22", "1970-01-01"])})]
+    )
+    def test_pos_raises(self, df):
+        msg = "Unary plus expects .* dtype, not datetime64\\[ns\\]"
+        with pytest.raises(TypeError, match=msg):
+            (+df)
+        with pytest.raises(TypeError, match=msg):
+            (+df["a"])

pandas/tests/series/test_operators.py

@@ -473,56 +473,3 @@ def test_logical_ops_df_compat(self):
 
         tm.assert_frame_equal(s3.to_frame() | s4.to_frame(), exp_or1.to_frame())
         tm.assert_frame_equal(s4.to_frame() | s3.to_frame(), exp_or.to_frame())
-
-
-class TestSeriesUnaryOps:
-    # __neg__, __pos__, __inv__
-
-    def test_neg(self):
-        ser = tm.makeStringSeries()
-        ser.name = "series"
-        tm.assert_series_equal(-ser, -1 * ser)
-
-    def test_invert(self):
-        ser = tm.makeStringSeries()
-        ser.name = "series"
-        tm.assert_series_equal(-(ser < 0), ~(ser < 0))
-
-    @pytest.mark.parametrize(
-        "source, target",
-        [
-            ([1, 2, 3], [-1, -2, -3]),
-            ([1, 2, None], [-1, -2, None]),
-            ([-1, 0, 1], [1, 0, -1]),
-        ],
-    )
-    def test_unary_minus_nullable_int(
-        self, any_signed_nullable_int_dtype, source, target
-    ):
-        dtype = any_signed_nullable_int_dtype
-        s = pd.Series(source, dtype=dtype)
-        result = -s
-        expected = pd.Series(target, dtype=dtype)
-        tm.assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize("source", [[1, 2, 3], [1, 2, None], [-1, 0, 1]])
-    def test_unary_plus_nullable_int(self, any_signed_nullable_int_dtype, source):
-        dtype = any_signed_nullable_int_dtype
-        expected = pd.Series(source, dtype=dtype)
-        result = +expected
-        tm.assert_series_equal(result, expected)
-
-    @pytest.mark.parametrize(
-        "source, target",
-        [
-            ([1, 2, 3], [1, 2, 3]),
-            ([1, -2, None], [1, 2, None]),
-            ([-1, 0, 1], [1, 0, 1]),
-        ],
-    )
-    def test_abs_nullable_int(self, any_signed_nullable_int_dtype, source, target):
-        dtype = any_signed_nullable_int_dtype
-        s = pd.Series(source, dtype=dtype)
-        result = abs(s)
-        expected = pd.Series(target, dtype=dtype)
-        tm.assert_series_equal(result, expected)

pandas/tests/series/test_unary.py

@@ -0,0 +1,57 @@
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestSeriesUnaryOps:
+    # __neg__, __pos__, __inv__
+
+    def test_neg(self):
+        ser = tm.makeStringSeries()
+        ser.name = "series"
+        tm.assert_series_equal(-ser, -1 * ser)
+
+    def test_invert(self):
+        ser = tm.makeStringSeries()
+        ser.name = "series"
+        tm.assert_series_equal(-(ser < 0), ~(ser < 0))
+
+    @pytest.mark.parametrize(
+        "source, target",
+        [
+            ([1, 2, 3], [-1, -2, -3]),
+            ([1, 2, None], [-1, -2, None]),
+            ([-1, 0, 1], [1, 0, -1]),
+        ],
+    )
+    def test_unary_minus_nullable_int(
+        self, any_signed_nullable_int_dtype, source, target
+    ):
+        dtype = any_signed_nullable_int_dtype
+        ser = Series(source, dtype=dtype)
+        result = -ser
+        expected = Series(target, dtype=dtype)
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("source", [[1, 2, 3], [1, 2, None], [-1, 0, 1]])
+    def test_unary_plus_nullable_int(self, any_signed_nullable_int_dtype, source):
+        dtype = any_signed_nullable_int_dtype
+        expected = Series(source, dtype=dtype)
+        result = +expected
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "source, target",
+        [
+            ([1, 2, 3], [1, 2, 3]),
+            ([1, -2, None], [1, 2, None]),
+            ([-1, 0, 1], [1, 0, 1]),
+        ],
+    )
+    def test_abs_nullable_int(self, any_signed_nullable_int_dtype, source, target):
+        dtype = any_signed_nullable_int_dtype
+        ser = Series(source, dtype=dtype)
+        result = abs(ser)
+        expected = Series(target, dtype=dtype)
+        tm.assert_series_equal(result, expected)