From e442346cc0389b213dbd10f20e97b18b73595275 Mon Sep 17 00:00:00 2001 From: Simon Hawkins Date: Tue, 11 May 2021 16:27:18 +0100 Subject: [PATCH 1/2] [ArrowStringArray] TST: parametrize tests/strings/test_case_justify.py --- pandas/tests/strings/test_case_justify.py | 387 ++++++++++++---------- 1 file changed, 221 insertions(+), 166 deletions(-) diff --git a/pandas/tests/strings/test_case_justify.py b/pandas/tests/strings/test_case_justify.py index b46f50e430b54..f01d7ca7dcc40 100644 --- a/pandas/tests/strings/test_case_justify.py +++ b/pandas/tests/strings/test_case_justify.py @@ -1,4 +1,5 @@ from datetime import datetime +import operator import numpy as np import pytest @@ -9,68 +10,80 @@ ) -def test_title(): - values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"]) +def test_title(any_string_dtype): + s = Series(["FOO", "BAR", np.nan, "Blah", "blurg"], dtype=any_string_dtype) + result = s.str.title() + expected = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) - result = values.str.title() - exp = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"]) - tm.assert_series_equal(result, exp) - # mixed - mixed = Series(["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]) - mixed = mixed.str.title() - exp = Series(["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan]) - tm.assert_almost_equal(mixed, exp) +def test_title_mixed_object(): + s = Series(["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]) + result = s.str.title() + expected = Series( + ["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan] + ) + tm.assert_almost_equal(result, expected) -def test_lower_upper(): - values = Series(["om", np.nan, "nom", "nom"]) +def test_lower_upper(any_string_dtype): + s = Series(["om", np.nan, "nom", "nom"], dtype=any_string_dtype) - result = values.str.upper() - exp = Series(["OM", np.nan, "NOM", "NOM"]) - tm.assert_series_equal(result, exp) + result = s.str.upper() + expected = Series(["OM", np.nan, "NOM", "NOM"], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) result = result.str.lower() - tm.assert_series_equal(result, values) + tm.assert_series_equal(result, s) - # mixed - mixed = Series(["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0]) - mixed = mixed.str.upper() - rs = Series(mixed).str.lower() - xp = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan]) - assert isinstance(rs, Series) - tm.assert_series_equal(rs, xp) +def test_lower_upper_mixed_object(): + s = Series(["a", np.nan, "b", True, datetime.today(), "foo", None, 1, 2.0]) -def test_capitalize(): - values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"]) - result = values.str.capitalize() - exp = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"]) - tm.assert_series_equal(result, exp) + result = s.str.upper() + expected = Series(["A", np.nan, "B", np.nan, np.nan, "FOO", np.nan, np.nan, np.nan]) + tm.assert_series_equal(result, expected) - # mixed - mixed = Series(["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]) - mixed = mixed.str.capitalize() - exp = Series(["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan]) - tm.assert_almost_equal(mixed, exp) + result = s.str.lower() + expected = Series(["a", np.nan, "b", np.nan, np.nan, "foo", np.nan, np.nan, np.nan]) + tm.assert_series_equal(result, expected) -def test_swapcase(): - values = Series(["FOO", "BAR", np.nan, "Blah", "blurg"]) - result = values.str.swapcase() - exp = Series(["foo", "bar", np.nan, "bLAH", "BLURG"]) - tm.assert_series_equal(result, exp) +def test_capitalize(any_string_dtype): + s = Series(["FOO", "BAR", np.nan, "Blah", "blurg"], dtype=any_string_dtype) + result = s.str.capitalize() + expected = Series(["Foo", "Bar", np.nan, "Blah", "Blurg"], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + - # mixed - mixed = Series(["FOO", np.nan, "bar", True, datetime.today(), "Blah", None, 1, 2.0]) - mixed = mixed.str.swapcase() - exp = Series(["foo", np.nan, "BAR", np.nan, np.nan, "bLAH", np.nan, np.nan, np.nan]) - tm.assert_almost_equal(mixed, exp) +def test_capitalize_mixed_object(): + s = Series(["FOO", np.nan, "bar", True, datetime.today(), "blah", None, 1, 2.0]) + result = s.str.capitalize() + expected = Series( + ["Foo", np.nan, "Bar", np.nan, np.nan, "Blah", np.nan, np.nan, np.nan] + ) + tm.assert_series_equal(result, expected) -def test_casemethods(): +def test_swapcase(any_string_dtype): + s = Series(["FOO", "BAR", np.nan, "Blah", "blurg"], dtype=any_string_dtype) + result = s.str.swapcase() + expected = Series(["foo", "bar", np.nan, "bLAH", "BLURG"], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + +def test_swapcase_mixed_object(): + s = Series(["FOO", np.nan, "bar", True, datetime.today(), "Blah", None, 1, 2.0]) + result = s.str.swapcase() + expected = Series( + ["foo", np.nan, "BAR", np.nan, np.nan, "bLAH", np.nan, np.nan, np.nan] + ) + tm.assert_series_equal(result, expected) + + +def test_casemethods(any_string_dtype): values = ["aaa", "bbb", "CCC", "Dddd", "eEEE"] - s = Series(values) + s = Series(values, dtype=any_string_dtype) assert s.str.lower().tolist() == [v.lower() for v in values] assert s.str.upper().tolist() == [v.upper() for v in values] assert s.str.title().tolist() == [v.title() for v in values] @@ -78,108 +91,122 @@ def test_casemethods(): assert s.str.swapcase().tolist() == [v.swapcase() for v in values] -def test_pad(): - values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"]) +def test_pad(any_string_dtype): + s = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"], dtype=any_string_dtype) - result = values.str.pad(5, side="left") - exp = Series([" a", " b", np.nan, " c", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) + result = s.str.pad(5, side="left") + expected = Series( + [" a", " b", np.nan, " c", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) + + result = s.str.pad(5, side="right") + expected = Series( + ["a ", "b ", np.nan, "c ", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.pad(5, side="right") - exp = Series(["a ", "b ", np.nan, "c ", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) + result = s.str.pad(5, side="both") + expected = Series( + [" a ", " b ", np.nan, " c ", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.pad(5, side="both") - exp = Series([" a ", " b ", np.nan, " c ", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) - # mixed - mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0]) +def test_pad_mixed_object(): + s = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0]) - rs = Series(mixed).str.pad(5, side="left") - xp = Series( + result = s.str.pad(5, side="left") + expected = Series( [" a", np.nan, " b", np.nan, np.nan, " ee", np.nan, np.nan, np.nan] ) + tm.assert_series_equal(result, expected) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) - - mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0]) - - rs = Series(mixed).str.pad(5, side="right") - xp = Series( + result = s.str.pad(5, side="right") + expected = Series( ["a ", np.nan, "b ", np.nan, np.nan, "ee ", np.nan, np.nan, np.nan] ) + tm.assert_series_equal(result, expected) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) - - mixed = Series(["a", np.nan, "b", True, datetime.today(), "ee", None, 1, 2.0]) - - rs = Series(mixed).str.pad(5, side="both") - xp = Series( + result = s.str.pad(5, side="both") + expected = Series( [" a ", np.nan, " b ", np.nan, np.nan, " ee ", np.nan, np.nan, np.nan] ) + tm.assert_series_equal(result, expected) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) +def test_pad_fillchar(any_string_dtype): + s = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"], dtype=any_string_dtype) -def test_pad_fillchar(): + result = s.str.pad(5, side="left", fillchar="X") + expected = Series( + ["XXXXa", "XXXXb", np.nan, "XXXXc", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"]) + result = s.str.pad(5, side="right", fillchar="X") + expected = Series( + ["aXXXX", "bXXXX", np.nan, "cXXXX", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.pad(5, side="left", fillchar="X") - exp = Series(["XXXXa", "XXXXb", np.nan, "XXXXc", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) + result = s.str.pad(5, side="both", fillchar="X") + expected = Series( + ["XXaXX", "XXbXX", np.nan, "XXcXX", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.pad(5, side="right", fillchar="X") - exp = Series(["aXXXX", "bXXXX", np.nan, "cXXXX", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) - result = values.str.pad(5, side="both", fillchar="X") - exp = Series(["XXaXX", "XXbXX", np.nan, "XXcXX", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) +def test_pad_fillchar_bad_arg_raises(any_string_dtype): + s = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"], dtype=any_string_dtype) msg = "fillchar must be a character, not str" with pytest.raises(TypeError, match=msg): - result = values.str.pad(5, fillchar="XY") + s.str.pad(5, fillchar="XY") msg = "fillchar must be a character, not int" with pytest.raises(TypeError, match=msg): - result = values.str.pad(5, fillchar=5) + s.str.pad(5, fillchar=5) -@pytest.mark.parametrize("f", ["center", "ljust", "rjust", "zfill", "pad"]) -def test_pad_width(f): +@pytest.mark.parametrize("method_name", ["center", "ljust", "rjust", "zfill", "pad"]) +def test_pad_width_bad_arg_raises(method_name, any_string_dtype): # see gh-13598 - s = Series(["1", "22", "a", "bb"]) - msg = "width must be of integer type, not*" + s = Series(["1", "22", "a", "bb"], dtype=any_string_dtype) + op = operator.methodcaller(method_name, "f") + msg = "width must be of integer type, not str" with pytest.raises(TypeError, match=msg): - getattr(s.str, f)("f") + op(s.str) + +def test_center_ljust_rjust(any_string_dtype): + s = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"], dtype=any_string_dtype) -def test_center_ljust_rjust(): - values = Series(["a", "b", np.nan, "c", np.nan, "eeeeee"]) + result = s.str.center(5) + expected = Series( + [" a ", " b ", np.nan, " c ", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.center(5) - exp = Series([" a ", " b ", np.nan, " c ", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) + result = s.str.ljust(5) + expected = Series( + ["a ", "b ", np.nan, "c ", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.ljust(5) - exp = Series(["a ", "b ", np.nan, "c ", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) + result = s.str.rjust(5) + expected = Series( + [" a", " b", np.nan, " c", np.nan, "eeeeee"], dtype=any_string_dtype + ) + tm.assert_series_equal(result, expected) - result = values.str.rjust(5) - exp = Series([" a", " b", np.nan, " c", np.nan, "eeeeee"]) - tm.assert_almost_equal(result, exp) - # mixed - mixed = Series(["a", np.nan, "b", True, datetime.today(), "c", "eee", None, 1, 2.0]) +def test_center_ljust_rjust_mixed_object(): + s = Series(["a", np.nan, "b", True, datetime.today(), "c", "eee", None, 1, 2.0]) - rs = Series(mixed).str.center(5) - xp = Series( + result = s.str.center(5) + expected = Series( [ " a ", np.nan, @@ -193,11 +220,10 @@ def test_center_ljust_rjust(): np.nan, ] ) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) + tm.assert_series_equal(result, expected) - rs = Series(mixed).str.ljust(5) - xp = Series( + result = s.str.ljust(5) + expected = Series( [ "a ", np.nan, @@ -211,11 +237,10 @@ def test_center_ljust_rjust(): np.nan, ] ) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) + tm.assert_series_equal(result, expected) - rs = Series(mixed).str.rjust(5) - xp = Series( + result = s.str.rjust(5) + expected = Series( [ " a", np.nan, @@ -229,82 +254,105 @@ def test_center_ljust_rjust(): np.nan, ] ) - assert isinstance(rs, Series) - tm.assert_almost_equal(rs, xp) + tm.assert_series_equal(result, expected) -def test_center_ljust_rjust_fillchar(): - values = Series(["a", "bb", "cccc", "ddddd", "eeeeee"]) +def test_center_ljust_rjust_fillchar(any_string_dtype): + s = Series(["a", "bb", "cccc", "ddddd", "eeeeee"], dtype=any_string_dtype) - result = values.str.center(5, fillchar="X") - expected = Series(["XXaXX", "XXbbX", "Xcccc", "ddddd", "eeeeee"]) + result = s.str.center(5, fillchar="X") + expected = Series( + ["XXaXX", "XXbbX", "Xcccc", "ddddd", "eeeeee"], dtype=any_string_dtype + ) tm.assert_series_equal(result, expected) - expected = np.array([v.center(5, "X") for v in values.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) - result = values.str.ljust(5, fillchar="X") - expected = Series(["aXXXX", "bbXXX", "ccccX", "ddddd", "eeeeee"]) + if any_string_dtype == "object": + expected = np.array([v.center(5, "X") for v in s.values], dtype=np.object_) + tm.assert_numpy_array_equal(result.values, expected) + + result = s.str.ljust(5, fillchar="X") + expected = Series( + ["aXXXX", "bbXXX", "ccccX", "ddddd", "eeeeee"], dtype=any_string_dtype + ) tm.assert_series_equal(result, expected) - expected = np.array([v.ljust(5, "X") for v in values.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) - result = values.str.rjust(5, fillchar="X") - expected = Series(["XXXXa", "XXXbb", "Xcccc", "ddddd", "eeeeee"]) + if any_string_dtype == "object": + expected = np.array([v.ljust(5, "X") for v in s.values], dtype=np.object_) + tm.assert_numpy_array_equal(result.values, expected) + + result = s.str.rjust(5, fillchar="X") + expected = Series( + ["XXXXa", "XXXbb", "Xcccc", "ddddd", "eeeeee"], dtype=any_string_dtype + ) tm.assert_series_equal(result, expected) - expected = np.array([v.rjust(5, "X") for v in values.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) - # If fillchar is not a charatter, normal str raises TypeError + if any_string_dtype == "object": + expected = np.array([v.rjust(5, "X") for v in s.values], dtype=np.object_) + tm.assert_numpy_array_equal(result.values, expected) + + +def test_center_ljust_rjust_fillchar_bad_arg_raises(any_string_dtype): + s = Series(["a", "bb", "cccc", "ddddd", "eeeeee"], dtype=any_string_dtype) + + # If fillchar is not a character, normal str raises TypeError # 'aaa'.ljust(5, 'XY') # TypeError: must be char, not str template = "fillchar must be a character, not {dtype}" with pytest.raises(TypeError, match=template.format(dtype="str")): - values.str.center(5, fillchar="XY") + s.str.center(5, fillchar="XY") with pytest.raises(TypeError, match=template.format(dtype="str")): - values.str.ljust(5, fillchar="XY") + s.str.ljust(5, fillchar="XY") with pytest.raises(TypeError, match=template.format(dtype="str")): - values.str.rjust(5, fillchar="XY") + s.str.rjust(5, fillchar="XY") with pytest.raises(TypeError, match=template.format(dtype="int")): - values.str.center(5, fillchar=1) + s.str.center(5, fillchar=1) with pytest.raises(TypeError, match=template.format(dtype="int")): - values.str.ljust(5, fillchar=1) + s.str.ljust(5, fillchar=1) with pytest.raises(TypeError, match=template.format(dtype="int")): - values.str.rjust(5, fillchar=1) + s.str.rjust(5, fillchar=1) -def test_zfill(): - values = Series(["1", "22", "aaa", "333", "45678"]) +def test_zfill(any_string_dtype): + s = Series(["1", "22", "aaa", "333", "45678"], dtype=any_string_dtype) - result = values.str.zfill(5) - expected = Series(["00001", "00022", "00aaa", "00333", "45678"]) + result = s.str.zfill(5) + expected = Series( + ["00001", "00022", "00aaa", "00333", "45678"], dtype=any_string_dtype + ) tm.assert_series_equal(result, expected) - expected = np.array([v.zfill(5) for v in values.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) - result = values.str.zfill(3) - expected = Series(["001", "022", "aaa", "333", "45678"]) + if any_string_dtype == "object": + expected = np.array([v.zfill(5) for v in s.values], dtype=np.object_) + tm.assert_numpy_array_equal(result.values, expected) + + result = s.str.zfill(3) + expected = Series(["001", "022", "aaa", "333", "45678"], dtype=any_string_dtype) tm.assert_series_equal(result, expected) - expected = np.array([v.zfill(3) for v in values.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) - values = Series(["1", np.nan, "aaa", np.nan, "45678"]) - result = values.str.zfill(5) - expected = Series(["00001", np.nan, "00aaa", np.nan, "45678"]) + if any_string_dtype == "object": + expected = np.array([v.zfill(3) for v in s.values], dtype=np.object_) + tm.assert_numpy_array_equal(result.values, expected) + + s = Series(["1", np.nan, "aaa", np.nan, "45678"], dtype=any_string_dtype) + result = s.str.zfill(5) + expected = Series( + ["00001", np.nan, "00aaa", np.nan, "45678"], dtype=any_string_dtype + ) tm.assert_series_equal(result, expected) -def test_wrap(): +def test_wrap(any_string_dtype): # test values are: two words less than width, two words equal to width, # two words greater than width, one word less than width, one word # equal to width, one word greater than width, multiple tokens with # trailing whitespace equal to width - values = Series( + s = Series( [ "hello world", "hello world!", @@ -315,11 +363,12 @@ def test_wrap(): "ab ab ab ab ", "ab ab ab ab a", "\t", - ] + ], + dtype=any_string_dtype, ) # expected values - xp = Series( + expected = Series( [ "hello world", "hello world!", @@ -330,15 +379,21 @@ def test_wrap(): "ab ab ab ab", "ab ab ab ab\na", "", - ] + ], + dtype=any_string_dtype, ) - rs = values.str.wrap(12, break_long_words=True) - tm.assert_series_equal(rs, xp) + result = s.str.wrap(12, break_long_words=True) + tm.assert_series_equal(result, expected) + - # test with pre and post whitespace (non-unicode), NaN, and non-ascii - # Unicode - values = Series([" pre ", np.nan, "\xac\u20ac\U00008000 abadcafe"]) - xp = Series([" pre", np.nan, "\xac\u20ac\U00008000 ab\nadcafe"]) - rs = values.str.wrap(6) - tm.assert_series_equal(rs, xp) +def test_wrap_unicode(any_string_dtype): + # test with pre and post whitespace (non-unicode), NaN, and non-ascii Unicode + s = Series( + [" pre ", np.nan, "\xac\u20ac\U00008000 abadcafe"], dtype=any_string_dtype + ) + expected = Series( + [" pre", np.nan, "\xac\u20ac\U00008000 ab\nadcafe"], dtype=any_string_dtype + ) + result = s.str.wrap(6) + tm.assert_series_equal(result, expected) From 8aa2fdd013f34695c19bddde318cddb028679dae Mon Sep 17 00:00:00 2001 From: Simon Hawkins Date: Wed, 12 May 2021 10:09:34 +0100 Subject: [PATCH 2/2] do not special case any_string_dtype --- pandas/tests/strings/test_case_justify.py | 30 ++++++++--------------- 1 file changed, 10 insertions(+), 20 deletions(-) diff --git a/pandas/tests/strings/test_case_justify.py b/pandas/tests/strings/test_case_justify.py index f01d7ca7dcc40..d6e2ca7399b4e 100644 --- a/pandas/tests/strings/test_case_justify.py +++ b/pandas/tests/strings/test_case_justify.py @@ -265,30 +265,24 @@ def test_center_ljust_rjust_fillchar(any_string_dtype): ["XXaXX", "XXbbX", "Xcccc", "ddddd", "eeeeee"], dtype=any_string_dtype ) tm.assert_series_equal(result, expected) - - if any_string_dtype == "object": - expected = np.array([v.center(5, "X") for v in s.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) + expected = np.array([v.center(5, "X") for v in np.array(s)], dtype=np.object_) + tm.assert_numpy_array_equal(np.array(result, dtype=np.object_), expected) result = s.str.ljust(5, fillchar="X") expected = Series( ["aXXXX", "bbXXX", "ccccX", "ddddd", "eeeeee"], dtype=any_string_dtype ) tm.assert_series_equal(result, expected) - - if any_string_dtype == "object": - expected = np.array([v.ljust(5, "X") for v in s.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) + expected = np.array([v.ljust(5, "X") for v in np.array(s)], dtype=np.object_) + tm.assert_numpy_array_equal(np.array(result, dtype=np.object_), expected) result = s.str.rjust(5, fillchar="X") expected = Series( ["XXXXa", "XXXbb", "Xcccc", "ddddd", "eeeeee"], dtype=any_string_dtype ) tm.assert_series_equal(result, expected) - - if any_string_dtype == "object": - expected = np.array([v.rjust(5, "X") for v in s.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) + expected = np.array([v.rjust(5, "X") for v in np.array(s)], dtype=np.object_) + tm.assert_numpy_array_equal(np.array(result, dtype=np.object_), expected) def test_center_ljust_rjust_fillchar_bad_arg_raises(any_string_dtype): @@ -326,18 +320,14 @@ def test_zfill(any_string_dtype): ["00001", "00022", "00aaa", "00333", "45678"], dtype=any_string_dtype ) tm.assert_series_equal(result, expected) - - if any_string_dtype == "object": - expected = np.array([v.zfill(5) for v in s.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) + expected = np.array([v.zfill(5) for v in np.array(s)], dtype=np.object_) + tm.assert_numpy_array_equal(np.array(result, dtype=np.object_), expected) result = s.str.zfill(3) expected = Series(["001", "022", "aaa", "333", "45678"], dtype=any_string_dtype) tm.assert_series_equal(result, expected) - - if any_string_dtype == "object": - expected = np.array([v.zfill(3) for v in s.values], dtype=np.object_) - tm.assert_numpy_array_equal(result.values, expected) + expected = np.array([v.zfill(3) for v in np.array(s)], dtype=np.object_) + tm.assert_numpy_array_equal(np.array(result, dtype=np.object_), expected) s = Series(["1", np.nan, "aaa", np.nan, "45678"], dtype=any_string_dtype) result = s.str.zfill(5)