diff --git a/python/cudf/cudf/tests/indexes/timedeltaindex/test_binops.py b/python/cudf/cudf/tests/indexes/timedeltaindex/test_binops.py index 640d25560ed5..11a1f5d1a35c 100644 --- a/python/cudf/cudf/tests/indexes/timedeltaindex/test_binops.py +++ b/python/cudf/cudf/tests/indexes/timedeltaindex/test_binops.py @@ -138,6 +138,9 @@ def test_timedelta_datetime_index_ops_misc( np.timedelta64(1, "ns"), ], ) +@pytest.mark.parametrize( + "arithmetic_op_method", ["add", "sub", "truediv", "floordiv"] +) @pytest.mark.filterwarnings("ignore:divide by zero:RuntimeWarning:pandas") def test_timedelta_index_ops_with_scalars( request, @@ -146,9 +149,6 @@ def test_timedelta_index_ops_with_scalars( timedelta_types_as_str, arithmetic_op_method, ): - if arithmetic_op_method not in ("add", "sub", "truediv", "floordiv"): - pytest.skip(f"Test not applicable for {arithmetic_op_method}") - gtdi = cudf.Index(data=data_non_overflow, dtype=timedelta_types_as_str) ptdi = gtdi.to_pandas() diff --git a/python/cudf/cudf/tests/series/methods/test_reductions.py b/python/cudf/cudf/tests/series/methods/test_reductions.py index 0074ab58c570..8c6d19b61691 100644 --- a/python/cudf/cudf/tests/series/methods/test_reductions.py +++ b/python/cudf/cudf/tests/series/methods/test_reductions.py @@ -866,11 +866,12 @@ def test_categorical_reductions(request, reduction_methods): [12, 11, 2.32, 2234.32411, 2343.241, 23432.4, 23234], ], ) +@pytest.mark.parametrize( + "reduction_methods", ["sum", "mean", "median", "quantile"] +) def test_timedelta_reduction_ops( data_non_overflow, timedelta_types_as_str, reduction_methods ): - if reduction_methods not in ["sum", "mean", "median", "quantile"]: - pytest.skip(f"{reduction_methods} not supported for timedelta") gsr = cudf.Series(data_non_overflow, dtype=timedelta_types_as_str) psr = gsr.to_pandas() @@ -1103,9 +1104,8 @@ def test_object_min_max_with_null(method, skipna): @pytest.mark.parametrize("data", [[1, 2, 3], [], [1, 20, 1000, None]]) +@pytest.mark.parametrize("reduction_methods", ["mean", "quantile"]) def test_datetime_stats(data, datetime_types_as_str, reduction_methods): - if reduction_methods not in ["mean", "quantile"]: - pytest.skip(f"{reduction_methods} not applicable for test") gsr = cudf.Series(data, dtype=datetime_types_as_str) psr = gsr.to_pandas() @@ -1129,9 +1129,8 @@ def test_datetime_stats(data, datetime_types_as_str, reduction_methods): [1231], ], ) +@pytest.mark.parametrize("reduction_methods", ["max", "min", "std", "median"]) def test_datetime_reductions(data, reduction_methods, datetime_types_as_str): - if reduction_methods not in ["max", "min", "std", "median"]: - pytest.skip(f"{reduction_methods} not applicable for test") sr = cudf.Series(data, dtype=datetime_types_as_str) psr = sr.to_pandas() diff --git a/python/cudf/cudf/tests/series/test_binops.py b/python/cudf/cudf/tests/series/test_binops.py index d82dacb0e59d..97b218f50600 100644 --- a/python/cudf/cudf/tests/series/test_binops.py +++ b/python/cudf/cudf/tests/series/test_binops.py @@ -21,6 +21,33 @@ gen_rand_series, ) +TIMEDELTA_SERIES_BINARY_OP_METHODS = [ + "add", + "radd", + "sub", + "rsub", + "truediv", + "rtruediv", + "floordiv", + "rfloordiv", + "mod", + "rmod", + "lt", + "le", + "eq", + "ne", + "ge", + "gt", +] + +TIMEDELTA_SCALAR_ARITHMETIC_OP_METHODS = [ + "add", + "sub", + "truediv", + "floordiv", + "mod", +] + @pytest.mark.parametrize( "sr1", [pd.Series([10, 11, 12], index=["a", "b", "z"]), pd.Series(["a"])] @@ -60,11 +87,12 @@ def test_series_error_equality(sr1, sr2, comparison_op): (cp.asarray([10, 20, 30, 100]), cp.asarray([10, 20, 30, 100])), ], ) +@pytest.mark.parametrize( + "binary_op_method", TIMEDELTA_SERIES_BINARY_OP_METHODS +) def test_timedelta_ops_misc_inputs( data, other, timedelta_types_as_str, binary_op_method ): - if binary_op_method in {"mul", "rmul", "pow", "rpow"}: - pytest.skip(f"Test not applicable for {binary_op_method}") gsr = cudf.Series(data, dtype=timedelta_types_as_str) other_gsr = cudf.Series(other, dtype=timedelta_types_as_str) @@ -232,21 +260,12 @@ def test_timedelta_dataframe_ops(df, op): np.timedelta64(1, "ns"), ], ) +@pytest.mark.parametrize( + "arithmetic_op_method", TIMEDELTA_SCALAR_ARITHMETIC_OP_METHODS +) def test_timedelta_series_ops_with_scalars( - data, other_scalars, timedelta_types_as_str, arithmetic_op_method, request + data, other_scalars, timedelta_types_as_str, arithmetic_op_method ): - if arithmetic_op_method in { - "mul", - "rmul", - "rtruediv", - "pow", - "rpow", - "radd", - "rsub", - "rfloordiv", - "rmod", - }: - pytest.skip(f"Test not applicable for {arithmetic_op_method}") gsr = cudf.Series(data=data, dtype=timedelta_types_as_str) psr = gsr.to_pandas() diff --git a/python/cudf/cudf/tests/window/test_rolling.py b/python/cudf/cudf/tests/window/test_rolling.py index 01888ec69502..5c72de6a8be7 100644 --- a/python/cudf/cudf/tests/window/test_rolling.py +++ b/python/cudf/cudf/tests/window/test_rolling.py @@ -19,19 +19,9 @@ def center(request): return request.param -@pytest.fixture -def supported_rolling_reductions(reduction_methods): - if reduction_methods in [ - "product", - "quantile", - "all", - "any", - "median", - "kurtosis", - "skew", - ]: - pytest.skip(f"{reduction_methods} not implemented") - return reduction_methods +@pytest.fixture(params=["min", "max", "sum", "std", "var"]) +def supported_rolling_reductions(request): + return request.param @pytest.mark.parametrize( @@ -140,10 +130,15 @@ def test_rolling_with_offset(supported_rolling_reductions): ) -@pytest.mark.parametrize("agg", ["std", "var"]) -@pytest.mark.parametrize("ddof", [0, 1]) -@pytest.mark.parametrize("window_size", [2, 100]) -def test_rolling_var_std_large(agg, ddof, center, window_size): +@pytest.fixture(scope="module", params=[2, 100]) +def rolling_var_std_window_size(request): + return request.param + + +@pytest.fixture(scope="module") +def rolling_var_std_large_data(rolling_var_std_window_size): + # All consumers only read these inputs while varying the rolling options. + window_size = rolling_var_std_window_size iupper_bound = math.sqrt(np.iinfo(np.int64).max / window_size) ilower_bound = -math.sqrt(abs(np.iinfo(np.int64).min) / window_size) @@ -180,7 +175,20 @@ def test_rolling_var_std_large(agg, ddof, center, window_size): seed=100, ) gdf = cudf.DataFrame.from_arrow(data) - pdf = gdf.to_pandas() + return gdf, gdf.to_pandas() + + +@pytest.mark.parametrize("agg", ["std", "var"]) +@pytest.mark.parametrize("ddof", [0, 1]) +def test_rolling_var_std_large( + agg, + ddof, + center, + rolling_var_std_window_size, + rolling_var_std_large_data, +): + window_size = rolling_var_std_window_size + gdf, pdf = rolling_var_std_large_data expect = getattr(pdf.rolling(window_size, 1, center), agg)(ddof=ddof) got = getattr(gdf.rolling(window_size, 1, center), agg)(ddof=ddof) @@ -370,11 +378,15 @@ def some_func(A): ) -@pytest.mark.parametrize("window_size", [1, 2, 3]) -@pytest.mark.parametrize("min_periods", [1, 2, 3]) +@pytest.mark.parametrize( + "window_size,min_periods", + [ + (window_size, min_periods) + for window_size in [1, 2, 3] + for min_periods in range(1, window_size + 1) + ], +) def test_rolling_groupby_numba_udf(window_size, min_periods): - if min_periods > window_size: - pytest.skip("min_periods cannot exceed window_size") pdf = pd.DataFrame( { "a": [1, 1, 1, 2, 2, 2, 2],