TST: skip -> xfail (#46387)

Author: mroeschke

pandas/tests/frame/methods/test_between_time.py

@@ -18,7 +18,7 @@
 
 
 class TestBetweenTime:
-    @td.skip_if_has_locale
+    @td.skip_if_not_us_locale
     def test_between_time_formats(self, frame_or_series):
         # GH#11818
         rng = date_range("1/1/2000", "1/5/2000", freq="5min")

pandas/tests/groupby/test_quantile.py

@@ -34,10 +34,13 @@
     ],
 )
 @pytest.mark.parametrize("q", [0, 0.25, 0.5, 0.75, 1])
-def test_quantile(interpolation, a_vals, b_vals, q):
+def test_quantile(interpolation, a_vals, b_vals, q, request):
     if interpolation == "nearest" and q == 0.5 and b_vals == [4, 3, 2, 1]:
-        pytest.skip(
-            "Unclear numpy expectation for nearest result with equidistant data"
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Unclear numpy expectation for nearest "
+                "result with equidistant data"
+            )
         )
 
     a_expected = pd.Series(a_vals).quantile(q, interpolation=interpolation)

pandas/tests/io/formats/test_series_info.py

@@ -116,7 +116,7 @@ def test_info_shows_dtypes():
         assert name in res
 
 
-@pytest.mark.skipif(PYPY, reason="on PyPy deep=True doesn't change result")
+@pytest.mark.xfail(PYPY, reason="on PyPy deep=True doesn't change result")
 def test_info_memory_usage_deep_not_pypy():
     s_with_object_index = Series({"a": [1]}, index=["foo"])
     assert s_with_object_index.memory_usage(
@@ -127,7 +127,7 @@ def test_info_memory_usage_deep_not_pypy():
     assert s_object.memory_usage(deep=True) > s_object.memory_usage()
 
 
-@pytest.mark.skipif(not PYPY, reason="on PyPy deep=True does not change result")
+@pytest.mark.xfail(not PYPY, reason="on PyPy deep=True does not change result")
 def test_info_memory_usage_deep_pypy():
     s_with_object_index = Series({"a": [1]}, index=["foo"])
     assert s_with_object_index.memory_usage(

pandas/tests/io/json/test_ujson.py

@@ -945,9 +945,11 @@ def test_array_numpy_labelled(self):
 
 
 class TestPandasJSONTests:
-    def test_dataframe(self, orient, numpy):
+    def test_dataframe(self, request, orient, numpy):
         if orient == "records" and numpy:
-            pytest.skip("Not idiomatic pandas")
+            request.node.add_marker(
+                pytest.mark.xfail(reason=f"Not idiomatic pandas if orient={orient}")
+            )
 
         dtype = get_int32_compat_dtype(numpy, orient)
 

pandas/tests/io/parser/common/test_read_errors.py

@@ -241,11 +241,16 @@ def test_null_byte_char(all_parsers):
 
 
 @td.check_file_leaks
-def test_open_file(all_parsers):
+def test_open_file(request, all_parsers):
     # GH 39024
     parser = all_parsers
     if parser.engine == "c":
-        pytest.skip("'c' engine does not support sep=None with delim_whitespace=False")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason=f"{parser.engine} engine does not support sep=None "
+                f"with delim_whitespace=False"
+            )
+        )
 
     with tm.ensure_clean() as path:
         file = Path(path)

pandas/tests/io/parser/dtypes/test_dtypes_basic.py

@@ -191,31 +191,39 @@ def test_delimiter_with_usecols_and_parse_dates(all_parsers):
 
 
 @pytest.mark.parametrize("thousands", ["_", None])
-def test_decimal_and_exponential(python_parser_only, numeric_decimal, thousands):
+def test_decimal_and_exponential(
+    request, python_parser_only, numeric_decimal, thousands
+):
     # GH#31920
-    decimal_number_check(python_parser_only, numeric_decimal, thousands, None)
+    decimal_number_check(request, python_parser_only, numeric_decimal, thousands, None)
 
 
 @pytest.mark.parametrize("thousands", ["_", None])
 @pytest.mark.parametrize("float_precision", [None, "legacy", "high", "round_trip"])
 def test_1000_sep_decimal_float_precision(
-    c_parser_only, numeric_decimal, float_precision, thousands
+    request, c_parser_only, numeric_decimal, float_precision, thousands
 ):
     # test decimal and thousand sep handling in across 'float_precision'
     # parsers
-    decimal_number_check(c_parser_only, numeric_decimal, thousands, float_precision)
+    decimal_number_check(
+        request, c_parser_only, numeric_decimal, thousands, float_precision
+    )
     text, value = numeric_decimal
     text = " " + text + " "
     if isinstance(value, str):  # the negative cases (parse as text)
         value = " " + value + " "
-    decimal_number_check(c_parser_only, (text, value), thousands, float_precision)
+    decimal_number_check(
+        request, c_parser_only, (text, value), thousands, float_precision
+    )
 
 
-def decimal_number_check(parser, numeric_decimal, thousands, float_precision):
+def decimal_number_check(request, parser, numeric_decimal, thousands, float_precision):
     # GH#31920
     value = numeric_decimal[0]
-    if thousands is None and "_" in value:
-        pytest.skip("Skip test if no thousands sep is defined and sep is in value")
+    if thousands is None and value in ("1_,", "1_234,56", "1_234,56e0"):
+        request.node.add_marker(
+            pytest.mark.xfail(reason=f"thousands={thousands} and sep is in {value}")
+        )
     df = parser.read_csv(
         StringIO(value),
         float_precision=float_precision,

pandas/tests/io/parser/test_compression.py

@@ -91,15 +91,19 @@ def test_zip_error_invalid_zip(parser_and_data):
 
 @skip_pyarrow
 @pytest.mark.parametrize("filename", [None, "test.{ext}"])
-def test_compression(parser_and_data, compression_only, buffer, filename):
+def test_compression(request, parser_and_data, compression_only, buffer, filename):
     parser, data, expected = parser_and_data
     compress_type = compression_only
 
     ext = icom._compression_to_extension[compress_type]
     filename = filename if filename is None else filename.format(ext=ext)
 
     if filename and buffer:
-        pytest.skip("Cannot deduce compression from buffer of compressed data.")
+        request.node.add_marker(
+            pytest.mark.xfail(
+                reason="Cannot deduce compression from buffer of compressed data."
+            )
+        )
 
     with tm.ensure_clean(filename=filename) as path:
         tm.write_to_compressed(compress_type, path, data)

pandas/tests/io/parser/test_unsupported.py

@@ -191,11 +191,13 @@ def test_close_file_handle_on_invalid_usecols(all_parsers):
         os.unlink(fname)
 
 
-def test_invalid_file_inputs(all_parsers):
+def test_invalid_file_inputs(request, all_parsers):
     # GH#45957
     parser = all_parsers
     if parser.engine == "python":
-        pytest.skip("Python engine supports lists.")
+        request.node.add_marker(
+            pytest.mark.xfail(reason=f"{parser.engine} engine supports lists.")
+        )
 
     with pytest.raises(ValueError, match="Invalid"):
         parser.read_csv([])

pandas/tests/io/test_sql.py

@@ -1719,7 +1719,7 @@ def test_default_date_load(self):
         # MySQL SHOULD be converted.
         assert issubclass(df.DateCol.dtype.type, np.datetime64)
 
-    def test_datetime_with_timezone(self):
+    def test_datetime_with_timezone(self, request):
         # edge case that converts postgresql datetime with time zone types
         # to datetime64[ns,psycopg2.tz.FixedOffsetTimezone..], which is ok
         # but should be more natural, so coerce to datetime64[ns] for now
@@ -1760,7 +1760,9 @@ def check(col):
         # GH11216
         df = read_sql_query("select * from types", self.conn)
         if not hasattr(df, "DateColWithTz"):
-            pytest.skip("no column with datetime with time zone")
+            request.node.add_marker(
+                pytest.mark.xfail(reason="no column with datetime with time zone")
+            )
 
         # this is parsed on Travis (linux), but not on macosx for some reason
         # even with the same versions of psycopg2 & sqlalchemy, possibly a
@@ -1772,7 +1774,9 @@ def check(col):
             "select * from types", self.conn, parse_dates=["DateColWithTz"]
         )
         if not hasattr(df, "DateColWithTz"):
-            pytest.skip("no column with datetime with time zone")
+            request.node.add_marker(
+                pytest.mark.xfail(reason="no column with datetime with time zone")
+            )
         col = df.DateColWithTz
         assert is_datetime64tz_dtype(col.dtype)
         assert str(col.dt.tz) == "UTC"
@@ -2275,8 +2279,9 @@ def test_get_engine_auto_error_message(self):
 
 
 class _TestSQLAlchemyConn(_EngineToConnMixin, _TestSQLAlchemy):
+    @pytest.mark.xfail(reason="Nested transactions rollbacks don't work with Pandas")
     def test_transactions(self):
-        pytest.skip("Nested transactions rollbacks don't work with Pandas")
+        super().test_transactions()
 
 
 class _TestSQLiteAlchemy:

pandas/tests/series/indexing/test_setitem.py

@@ -759,21 +759,13 @@ def test_series_where(self, obj, key, expected, val, is_inplace):
         self._check_inplace(is_inplace, orig, arr, obj)
 
     def test_index_where(self, obj, key, expected, val):
-        if obj.dtype.kind == "c" or expected.dtype.kind == "c":
-            # TODO(Index[complex]): Should become unreachable
-            pytest.skip("test not applicable for this dtype")
-
         mask = np.zeros(obj.shape, dtype=bool)
         mask[key] = True
 
         res = Index(obj).where(~mask, val)
         tm.assert_index_equal(res, Index(expected, dtype=expected.dtype))
 
     def test_index_putmask(self, obj, key, expected, val):
-        if obj.dtype.kind == "c" or expected.dtype.kind == "c":
-            # TODO(Index[complex]): Should become unreachable
-            pytest.skip("test not applicable for this dtype")
-
         mask = np.zeros(obj.shape, dtype=bool)
         mask[key] = True