TST/REF: collect tests by method, some misplaced

pandas/tests/arithmetic/test_categorical.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+from pandas import Categorical, Series
+import pandas._testing as tm
+
+
+class TestCategoricalComparisons:
+    def test_categorical_nan_equality(self):
+        cat = Series(Categorical(["a", "b", "c", np.nan]))
+        expected = Series([True, True, True, False])
+        result = cat == cat
+        tm.assert_series_equal(result, expected)

pandas/tests/frame/methods/test_asfreq.py

@@ -2,13 +2,31 @@
 
 import numpy as np
 
-from pandas import DataFrame, DatetimeIndex, Series, date_range
+from pandas import DataFrame, DatetimeIndex, Series, date_range, to_datetime
 import pandas._testing as tm
 
 from pandas.tseries import offsets
 
 
 class TestAsFreq:
+    def test_asfreq_resample_set_correct_freq(self):
+        # GH#5613
+        # we test if .asfreq() and .resample() set the correct value for .freq
+        df = DataFrame(
+            {"date": ["2012-01-01", "2012-01-02", "2012-01-03"], "col": [1, 2, 3]}
+        )
+        df = df.set_index(to_datetime(df.date))
+
+        # testing the settings before calling .asfreq() and .resample()
+        assert df.index.freq is None
+        assert df.index.inferred_freq == "D"
+
+        # does .asfreq() set .freq correctly?
+        assert df.asfreq("D").index.freq == "D"
+
+        # does .resample() set .freq correctly?
+        assert df.resample("D").asfreq().index.freq == "D"
+
     def test_asfreq(self, datetime_frame):
         offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd())
         rule_monthly = datetime_frame.asfreq("BM")

pandas/tests/indexes/datetimes/test_indexing.py

@@ -618,6 +618,16 @@ def test_get_indexer_out_of_bounds_date(self, target, positions):
         expected = np.array(positions, dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_get_indexer_pad_requires_monotonicity(self):
+        rng = date_range("1/1/2000", "3/1/2000", freq="B")
+
+        # neither monotonic increasing or decreasing
+        rng2 = rng[[1, 0, 2]]
+
+        msg = "index must be monotonic increasing or decreasing"
+        with pytest.raises(ValueError, match=msg):
+            rng2.get_indexer(rng, method="pad")
+
 
 class TestMaybeCastSliceBound:
     def test_maybe_cast_slice_bounds_empty(self):

pandas/tests/series/methods/test_convert.py

@@ -0,0 +1,203 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import NaT, Series, Timestamp
+import pandas._testing as tm
+
+
+class TestConvert:
+    def test_convert(self):
+        # GH#10265
+        # Tests: All to nans, coerce, true
+        # Test coercion returns correct type
+        ser = Series(["a", "b", "c"])
+        results = ser._convert(datetime=True, coerce=True)
+        expected = Series([NaT] * 3)
+        tm.assert_series_equal(results, expected)
+
+        results = ser._convert(numeric=True, coerce=True)
+        expected = Series([np.nan] * 3)
+        tm.assert_series_equal(results, expected)
+
+        expected = Series([NaT] * 3, dtype=np.dtype("m8[ns]"))
+        results = ser._convert(timedelta=True, coerce=True)
+        tm.assert_series_equal(results, expected)
+
+        dt = datetime(2001, 1, 1, 0, 0)
+        td = dt - datetime(2000, 1, 1, 0, 0)
+
+        # Test coercion with mixed types
+        ser = Series(["a", "3.1415", dt, td])
+        results = ser._convert(datetime=True, coerce=True)
+        expected = Series([NaT, NaT, dt, NaT])
+        tm.assert_series_equal(results, expected)
+
+        results = ser._convert(numeric=True, coerce=True)
+        expected = Series([np.nan, 3.1415, np.nan, np.nan])
+        tm.assert_series_equal(results, expected)
+
+        results = ser._convert(timedelta=True, coerce=True)
+        expected = Series([NaT, NaT, NaT, td], dtype=np.dtype("m8[ns]"))
+        tm.assert_series_equal(results, expected)
+
+        # Test standard conversion returns original
+        results = ser._convert(datetime=True)
+        tm.assert_series_equal(results, ser)
+        results = ser._convert(numeric=True)
+        expected = Series([np.nan, 3.1415, np.nan, np.nan])
+        tm.assert_series_equal(results, expected)
+        results = ser._convert(timedelta=True)
+        tm.assert_series_equal(results, ser)
+
+        # test pass-through and non-conversion when other types selected
+        ser = Series(["1.0", "2.0", "3.0"])
+        results = ser._convert(datetime=True, numeric=True, timedelta=True)
+        expected = Series([1.0, 2.0, 3.0])
+        tm.assert_series_equal(results, expected)
+        results = ser._convert(True, False, True)
+        tm.assert_series_equal(results, ser)
+
+        ser = Series(
+            [datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)], dtype="O"
+        )
+        results = ser._convert(datetime=True, numeric=True, timedelta=True)
+        expected = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 1, 0, 0)])
+        tm.assert_series_equal(results, expected)
+        results = ser._convert(datetime=False, numeric=True, timedelta=True)
+        tm.assert_series_equal(results, ser)
+
+        td = datetime(2001, 1, 1, 0, 0) - datetime(2000, 1, 1, 0, 0)
+        ser = Series([td, td], dtype="O")
+        results = ser._convert(datetime=True, numeric=True, timedelta=True)
+        expected = Series([td, td])
+        tm.assert_series_equal(results, expected)
+        results = ser._convert(True, True, False)
+        tm.assert_series_equal(results, ser)
+
+        ser = Series([1.0, 2, 3], index=["a", "b", "c"])
+        result = ser._convert(numeric=True)
+        tm.assert_series_equal(result, ser)
+
+        # force numeric conversion
+        res = ser.copy().astype("O")
+        res["a"] = "1"
+        result = res._convert(numeric=True)
+        tm.assert_series_equal(result, ser)
+
+        res = ser.copy().astype("O")
+        res["a"] = "1."
+        result = res._convert(numeric=True)
+        tm.assert_series_equal(result, ser)
+
+        res = ser.copy().astype("O")
+        res["a"] = "garbled"
+        result = res._convert(numeric=True)
+        expected = ser.copy()
+        expected["a"] = np.nan
+        tm.assert_series_equal(result, expected)
+
+        # GH 4119, not converting a mixed type (e.g.floats and object)
+        ser = Series([1, "na", 3, 4])
+        result = ser._convert(datetime=True, numeric=True)
+        expected = Series([1, np.nan, 3, 4])
+        tm.assert_series_equal(result, expected)
+
+        ser = Series([1, "", 3, 4])
+        result = ser._convert(datetime=True, numeric=True)
+        tm.assert_series_equal(result, expected)
+
+        # dates
+        ser = Series(
+            [
+                datetime(2001, 1, 1, 0, 0),
+                datetime(2001, 1, 2, 0, 0),
+                datetime(2001, 1, 3, 0, 0),
+            ]
+        )
+        s2 = Series(
+            [
+                datetime(2001, 1, 1, 0, 0),
+                datetime(2001, 1, 2, 0, 0),
+                datetime(2001, 1, 3, 0, 0),
+                "foo",
+                1.0,
+                1,
+                Timestamp("20010104"),
+                "20010105",
+            ],
+            dtype="O",
+        )
+
+        result = ser._convert(datetime=True)
+        expected = Series(
+            [Timestamp("20010101"), Timestamp("20010102"), Timestamp("20010103")],
+            dtype="M8[ns]",
+        )
+        tm.assert_series_equal(result, expected)
+
+        result = ser._convert(datetime=True, coerce=True)
+        tm.assert_series_equal(result, expected)
+
+        expected = Series(
+            [
+                Timestamp("20010101"),
+                Timestamp("20010102"),
+                Timestamp("20010103"),
+                NaT,
+                NaT,
+                NaT,
+                Timestamp("20010104"),
+                Timestamp("20010105"),
+            ],
+            dtype="M8[ns]",
+        )
+        result = s2._convert(datetime=True, numeric=False, timedelta=False, coerce=True)
+        tm.assert_series_equal(result, expected)
+        result = s2._convert(datetime=True, coerce=True)
+        tm.assert_series_equal(result, expected)
+
+        ser = Series(["foo", "bar", 1, 1.0], dtype="O")
+        result = ser._convert(datetime=True, coerce=True)
+        expected = Series([NaT] * 2 + [Timestamp(1)] * 2)
+        tm.assert_series_equal(result, expected)
+
+        # preserver if non-object
+        ser = Series([1], dtype="float32")
+        result = ser._convert(datetime=True, coerce=True)
+        tm.assert_series_equal(result, ser)
+
+        # FIXME: dont leave commented-out
+        # res = ser.copy()
+        # r[0] = np.nan
+        # result = res._convert(convert_dates=True,convert_numeric=False)
+        # assert result.dtype == 'M8[ns]'
+
+        # dateutil parses some single letters into today's value as a date
+        expected = Series([NaT])
+        for x in "abcdefghijklmnopqrstuvwxyz":
+            ser = Series([x])
+            result = ser._convert(datetime=True, coerce=True)
+            tm.assert_series_equal(result, expected)
+            ser = Series([x.upper()])
+            result = ser._convert(datetime=True, coerce=True)
+            tm.assert_series_equal(result, expected)
+
+    def test_convert_no_arg_error(self):
+        ser = Series(["1.0", "2"])
+        msg = r"At least one of datetime, numeric or timedelta must be True\."
+        with pytest.raises(ValueError, match=msg):
+            ser._convert()
+
+    def test_convert_preserve_bool(self):
+        ser = Series([1, True, 3, 5], dtype=object)
+        res = ser._convert(datetime=True, numeric=True)
+        expected = Series([1, 1, 3, 5], dtype="i8")
+        tm.assert_series_equal(res, expected)
+
+    def test_convert_preserve_all_bool(self):
+        ser = Series([False, True, False, False], dtype=object)
+        res = ser._convert(datetime=True, numeric=True)
+        expected = Series([False, True, False, False], dtype=bool)
+        tm.assert_series_equal(res, expected)

pandas/tests/series/methods/test_dropna.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pytest
+
+from pandas import DatetimeIndex, IntervalIndex, NaT, Period, Series, Timestamp
+import pandas._testing as tm
+
+
+class TestDropna:
+    def test_dropna_empty(self):
+        ser = Series([], dtype=object)
+
+        assert len(ser.dropna()) == 0
+        return_value = ser.dropna(inplace=True)
+        assert return_value is None
+        assert len(ser) == 0
+
+        # invalid axis
+        msg = "No axis named 1 for object type Series"
+        with pytest.raises(ValueError, match=msg):
+            ser.dropna(axis=1)
+
+    def test_dropna_preserve_name(self, datetime_series):
+        datetime_series[:5] = np.nan
+        result = datetime_series.dropna()
+        assert result.name == datetime_series.name
+        name = datetime_series.name
+        ts = datetime_series.copy()
+        return_value = ts.dropna(inplace=True)
+        assert return_value is None
+        assert ts.name == name
+
+    def test_dropna_no_nan(self):
+        for ser in [
+            Series([1, 2, 3], name="x"),
+            Series([False, True, False], name="x"),
+        ]:
+
+            result = ser.dropna()
+            tm.assert_series_equal(result, ser)
+            assert result is not ser
+
+            s2 = ser.copy()
+            return_value = s2.dropna(inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(s2, ser)
+
+    def test_dropna_intervals(self):
+        ser = Series(
+            [np.nan, 1, 2, 3],
+            IntervalIndex.from_arrays([np.nan, 0, 1, 2], [np.nan, 1, 2, 3]),
+        )
+
+        result = ser.dropna()
+        expected = ser.iloc[1:]
+        tm.assert_series_equal(result, expected)
+
+    def test_dropna_period_dtype(self):
+        # GH#13737
+        ser = Series([Period("2011-01", freq="M"), Period("NaT", freq="M")])
+        result = ser.dropna()
+        expected = Series([Period("2011-01", freq="M")])
+
+        tm.assert_series_equal(result, expected)
+
+    def test_datetime64_tz_dropna(self):
+        # DatetimeBlock
+        ser = Series(
+            [
+                Timestamp("2011-01-01 10:00"),
+                NaT,
+                Timestamp("2011-01-03 10:00"),
+                NaT,
+            ]
+        )
+        result = ser.dropna()
+        expected = Series(
+            [Timestamp("2011-01-01 10:00"), Timestamp("2011-01-03 10:00")], index=[0, 2]
+        )
+        tm.assert_series_equal(result, expected)
+
+        # DatetimeBlockTZ
+        idx = DatetimeIndex(
+            ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz="Asia/Tokyo"
+        )
+        ser = Series(idx)
+        assert ser.dtype == "datetime64[ns, Asia/Tokyo]"
+        result = ser.dropna()
+        expected = Series(
+            [
+                Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"),
+                Timestamp("2011-01-03 10:00", tz="Asia/Tokyo"),
+            ],
+            index=[0, 2],
+        )
+        assert result.dtype == "datetime64[ns, Asia/Tokyo]"
+        tm.assert_series_equal(result, expected)