more fixups

Author: MarcoGorelli

pandas/tests/dtypes/test_generic.py

@@ -18,7 +18,7 @@
 class TestABCClasses:
     tuples = [[1, 2, 2], ["red", "blue", "red"]]
     multi_index = pd.MultiIndex.from_arrays(tuples, names=("number", "color"))
-    datetime_index = pd.to_datetime(["1/1/2000", "1/1/2010"])
+    datetime_index = pd.to_datetime(["2000/1/1", "2010/1/1"])
     timedelta_index = pd.to_timedelta(np.arange(5), unit="s")
     period_index = pd.period_range("1/1/2000", "1/1/2010", freq="M")
     categorical = pd.Categorical([1, 2, 3], categories=[2, 3, 1])

pandas/tests/frame/methods/test_reset_index.py

@@ -337,19 +337,24 @@ def test_reset_index_multiindex_nan(self):
         tm.assert_frame_equal(rs, df)
 
     @pytest.mark.parametrize(
-        "name, warn",
+        "name",
         [
-            (None, UserWarning),
-            ("foo", UserWarning),
-            (2, None),
-            (3.0, None),
-            (pd.Timedelta(6), None),
-            (Timestamp("2012-12-30", tz="UTC"), FutureWarning),
-            ("2012-12-31", None),
+            None,
+            "foo",
+            2,
+            3.0,
+            pd.Timedelta(6),
+            Timestamp("2012-12-30", tz="UTC"),
+            "2012-12-31",
         ],
     )
-    def test_reset_index_with_datetimeindex_cols(self, name, warn):
+    def test_reset_index_with_datetimeindex_cols(self, name):
         # GH#5818
+        warn = None
+        if isinstance(name, Timestamp) and name.tz is not None:
+            # _deprecate_mismatched_indexing
+            warn = FutureWarning
+
         df = DataFrame(
             [[1, 2], [3, 4]],
             columns=date_range("1/1/2013", "1/2/2013"),

pandas/tests/tslibs/test_array_to_datetime.py

@@ -119,27 +119,30 @@ def test_number_looking_strings_not_into_datetime(data):
 
 
 @pytest.mark.parametrize(
-    "invalid_date",
+    "invalid_date, warn",
     [
-        date(1000, 1, 1),
-        datetime(1000, 1, 1),
-        "1000-01-01",
-        "Jan 1, 1000",
-        np.datetime64("1000-01-01"),
+        (date(1000, 1, 1), None),
+        (datetime(1000, 1, 1), None),
+        ("1000-01-01", None),
+        ("Jan 1, 1000", UserWarning),
+        (np.datetime64("1000-01-01"), None),
     ],
 )
 @pytest.mark.parametrize("errors", ["coerce", "raise"])
-def test_coerce_outside_ns_bounds(invalid_date, errors):
+def test_coerce_outside_ns_bounds(invalid_date, warn, errors):
     arr = np.array([invalid_date], dtype="object")
     kwargs = {"values": arr, "errors": errors}
 
     if errors == "raise":
         msg = "Out of bounds .* present at position 0"
 
-        with pytest.raises(ValueError, match=msg):
+        with pytest.raises(ValueError, match=msg), tm.assert_produces_warning(
+            warn, match="without a format specified"
+        ):
             tslib.array_to_datetime(**kwargs)
     else:  # coerce.
-        result, _ = tslib.array_to_datetime(**kwargs)
+        with tm.assert_produces_warning(warn, match="without a format specified"):
+            result, _ = tslib.array_to_datetime(**kwargs)
         expected = np.array([iNaT], dtype="M8[ns]")
 
         tm.assert_numpy_array_equal(result, expected)
@@ -163,17 +166,11 @@ def test_coerce_of_invalid_datetimes(errors):
     if errors == "ignore":
         # Without coercing, the presence of any invalid
         # dates prevents any values from being converted.
-        with tm.assert_produces_warning(
-            UserWarning, match="without a format specified"
-        ):
-            result, _ = tslib.array_to_datetime(**kwargs)
+        result, _ = tslib.array_to_datetime(**kwargs)
         tm.assert_numpy_array_equal(result, arr)
     else:  # coerce.
         # With coercing, the invalid dates becomes iNaT
-        with tm.assert_produces_warning(
-            UserWarning, match="without a format specified"
-        ):
-            result, _ = tslib.array_to_datetime(arr, errors="coerce")
+        result, _ = tslib.array_to_datetime(arr, errors="coerce")
         expected = ["2013-01-01T00:00:00.000000000", iNaT, iNaT]
 
         tm.assert_numpy_array_equal(result, np.array(expected, dtype="M8[ns]"))