diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 676757d8e095f..c5d338605b2ab 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -101,14 +101,11 @@
 if TYPE_CHECKING:
     from pandas._typing import (
         Dtype,
-        Frequency,
         NpDtype,
     )
 
     from pandas.core.arrays import ArrowExtensionArray
 
-_N = 30
-
 UNSIGNED_INT_NUMPY_DTYPES: list[NpDtype] = ["uint8", "uint16", "uint32", "uint64"]
 UNSIGNED_INT_EA_DTYPES: list[Dtype] = ["UInt8", "UInt16", "UInt32", "UInt64"]
 SIGNED_INT_NUMPY_DTYPES: list[NpDtype] = [int, "int8", "int16", "int32", "int64"]
@@ -339,16 +336,6 @@ def to_array(obj):
 # Others
 
 
-def makeTimeSeries(nper=None, freq: Frequency = "B", name=None) -> Series:
-    if nper is None:
-        nper = _N
-    return Series(
-        np.random.default_rng(2).standard_normal(nper),
-        index=date_range("2000-01-01", periods=nper, freq=freq),
-        name=name,
-    )
-
-
 def makeCustomIndex(
     nentries,
     nlevels,
@@ -883,7 +870,6 @@ def shares_memory(left, right) -> bool:
     "loc",
     "makeCustomDataframe",
     "makeCustomIndex",
-    "makeTimeSeries",
     "maybe_produces_warning",
     "NARROW_NP_DTYPES",
     "NP_NAT_OBJECTS",
diff --git a/pandas/conftest.py b/pandas/conftest.py
index 6401d4b5981e0..003474b57c8e1 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -766,9 +766,11 @@ def datetime_series() -> Series:
     """
     Fixture for Series of floats with DatetimeIndex
     """
-    s = tm.makeTimeSeries()
-    s.name = "ts"
-    return s
+    return Series(
+        np.random.default_rng(2).standard_normal(30),
+        index=date_range("2000-01-01", periods=30, freq="B"),
+        name="ts",
+    )
 
 
 def _create_series(index):
diff --git a/pandas/tests/apply/test_series_apply.py b/pandas/tests/apply/test_series_apply.py
index 24e48ebd4ed54..df24fa08f48e1 100644
--- a/pandas/tests/apply/test_series_apply.py
+++ b/pandas/tests/apply/test_series_apply.py
@@ -8,6 +8,7 @@
     MultiIndex,
     Series,
     concat,
+    date_range,
     timedelta_range,
 )
 import pandas._testing as tm
@@ -134,7 +135,7 @@ def foo2(x, b=2, c=0):
 
 def test_series_apply_map_box_timestamps(by_row):
     # GH#2689, GH#2627
-    ser = Series(pd.date_range("1/1/2000", periods=10))
+    ser = Series(date_range("1/1/2000", periods=10))
 
     def func(x):
         return (x.hour, x.day, x.month)
@@ -194,13 +195,11 @@ def test_apply_box_period():
 
 
 def test_apply_datetimetz(by_row):
-    values = pd.date_range("2011-01-01", "2011-01-02", freq="h").tz_localize(
-        "Asia/Tokyo"
-    )
+    values = date_range("2011-01-01", "2011-01-02", freq="h").tz_localize("Asia/Tokyo")
     s = Series(values, name="XX")
 
     result = s.apply(lambda x: x + pd.offsets.Day(), by_row=by_row)
-    exp_values = pd.date_range("2011-01-02", "2011-01-03", freq="h").tz_localize(
+    exp_values = date_range("2011-01-02", "2011-01-03", freq="h").tz_localize(
         "Asia/Tokyo"
     )
     exp = Series(exp_values, name="XX")
@@ -267,7 +266,7 @@ def test_apply_categorical_with_nan_values(series, by_row):
 
 def test_apply_empty_integer_series_with_datetime_index(by_row):
     # GH 21245
-    s = Series([], index=pd.date_range(start="2018-01-01", periods=0), dtype=int)
+    s = Series([], index=date_range(start="2018-01-01", periods=0), dtype=int)
     result = s.apply(lambda x: x, by_row=by_row)
     tm.assert_series_equal(result, s)
 
@@ -510,8 +509,12 @@ def test_series_apply_no_suffix_index(by_row):
             DataFrame(np.repeat([[1, 2]], 2, axis=0), dtype="int64"),
         ),
         (
-            tm.makeTimeSeries(nper=30),
-            DataFrame(np.repeat([[1, 2]], 30, axis=0), dtype="int64"),
+            Series(
+                np.arange(10, dtype=np.float64),
+                index=date_range("2020-01-01", periods=10),
+                name="ts",
+            ),
+            DataFrame(np.repeat([[1, 2]], 10, axis=0), dtype="int64"),
         ),
     ],
 )
@@ -528,12 +531,15 @@ def test_apply_series_on_date_time_index_aware_series(dti, exp, aware):
 
 
 @pytest.mark.parametrize(
-    "by_row, expected", [("compat", Series(np.ones(30), dtype="int64")), (False, 1)]
+    "by_row, expected", [("compat", Series(np.ones(10), dtype="int64")), (False, 1)]
 )
 def test_apply_scalar_on_date_time_index_aware_series(by_row, expected):
     # GH 25959
     # Calling apply on a localized time series should not cause an error
-    series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
+    series = Series(
+        np.arange(10, dtype=np.float64),
+        index=date_range("2020-01-01", periods=10, tz="UTC"),
+    )
     result = Series(series.index).apply(lambda x: 1, by_row=by_row)
     tm.assert_equal(result, expected)
 
diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py
index c3c4a8b4fc6c0..d3ce0e222e4cd 100644
--- a/pandas/tests/arithmetic/test_numeric.py
+++ b/pandas/tests/arithmetic/test_numeric.py
@@ -19,6 +19,7 @@
     Timedelta,
     TimedeltaIndex,
     array,
+    date_range,
 )
 import pandas._testing as tm
 from pandas.core import ops
@@ -733,7 +734,7 @@ def test_mul_datelike_raises(self, numeric_idx):
         idx = numeric_idx
         msg = "cannot perform __rmul__ with this index type"
         with pytest.raises(TypeError, match=msg):
-            idx * pd.date_range("20130101", periods=5)
+            idx * date_range("20130101", periods=5)
 
     def test_mul_size_mismatch_raises(self, numeric_idx):
         idx = numeric_idx
@@ -820,7 +821,11 @@ def test_ops_np_scalar(self, other):
     # TODO: This came from series.test.test_operators, needs cleanup
     def test_operators_frame(self):
         # rpow does not work with DataFrame
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         ts.name = "ts"
 
         df = pd.DataFrame({"A": ts})
@@ -926,8 +931,11 @@ def test_series_frame_radd_bug(self, fixed_now_ts):
         expected = pd.DataFrame({"vals": vals.map(lambda x: "foo_" + x)})
         tm.assert_frame_equal(result, expected)
 
-        ts = tm.makeTimeSeries()
-        ts.name = "ts"
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
 
         # really raise this time
         fix_now = fixed_now_ts.to_pydatetime()
@@ -955,8 +963,8 @@ def test_datetime64_with_index(self):
         # GH#4629
         # arithmetic datetime64 ops with an index
         ser = Series(
-            pd.date_range("20130101", periods=5),
-            index=pd.date_range("20130101", periods=5),
+            date_range("20130101", periods=5),
+            index=date_range("20130101", periods=5),
         )
         expected = ser - ser.index.to_series()
         result = ser - ser.index
@@ -969,7 +977,7 @@ def test_datetime64_with_index(self):
 
         df = pd.DataFrame(
             np.random.default_rng(2).standard_normal((5, 2)),
-            index=pd.date_range("20130101", periods=5),
+            index=date_range("20130101", periods=5),
         )
         df["date"] = pd.Timestamp("20130102")
         df["expected"] = df["date"] - df.index.to_series()
@@ -1031,7 +1039,11 @@ def test_frame_operators_empty_like(self, dtype):
     )
     def test_series_operators_arithmetic(self, all_arithmetic_functions, func):
         op = all_arithmetic_functions
-        series = tm.makeTimeSeries().rename("ts")
+        series = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         other = func(series)
         compare_op(series, other, op)
 
@@ -1040,7 +1052,11 @@ def test_series_operators_arithmetic(self, all_arithmetic_functions, func):
     )
     def test_series_operators_compare(self, comparison_op, func):
         op = comparison_op
-        series = tm.makeTimeSeries().rename("ts")
+        series = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         other = func(series)
         compare_op(series, other, op)
 
@@ -1050,7 +1066,11 @@ def test_series_operators_compare(self, comparison_op, func):
         ids=["multiply", "slice", "constant"],
     )
     def test_divmod(self, func):
-        series = tm.makeTimeSeries().rename("ts")
+        series = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         other = func(series)
         results = divmod(series, other)
         if isinstance(other, abc.Iterable) and len(series) != len(other):
@@ -1081,7 +1101,11 @@ def test_series_divmod_zero(self):
         #  -1/0 == -np.inf
         #  1/-0.0 == -np.inf
         #  -1/-0.0 == np.inf
-        tser = tm.makeTimeSeries().rename("ts")
+        tser = Series(
+            np.arange(1, 11, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         other = tser * 0
 
         result = divmod(tser, other)
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index b6a6334b89fc1..d0d971e29204a 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -609,7 +609,9 @@ def test_reindex_sparse(self):
         tm.assert_frame_equal(result, expected)
 
     def test_reindex(self, float_frame, using_copy_on_write):
-        datetime_series = tm.makeTimeSeries(nper=30)
+        datetime_series = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
 
         newFrame = float_frame.reindex(datetime_series.index)
 
diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py
index 84189f8149d81..c6fe3a154905c 100644
--- a/pandas/tests/frame/test_constructors.py
+++ b/pandas/tests/frame/test_constructors.py
@@ -500,9 +500,11 @@ def test_constructor_ordereddict(self):
         assert expected == list(df.columns)
 
     def test_constructor_dict(self):
-        datetime_series = tm.makeTimeSeries(nper=30)
+        datetime_series = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
         # test expects index shifted by 5
-        datetime_series_short = tm.makeTimeSeries(nper=30)[5:]
+        datetime_series_short = datetime_series[5:]
 
         frame = DataFrame({"col1": datetime_series, "col2": datetime_series_short})
 
@@ -626,8 +628,10 @@ def test_constructor_dict_nan_tuple_key(self, value):
         tm.assert_frame_equal(result, expected)
 
     def test_constructor_dict_order_insertion(self):
-        datetime_series = tm.makeTimeSeries(nper=30)
-        datetime_series_short = tm.makeTimeSeries(nper=25)
+        datetime_series = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
+        datetime_series_short = datetime_series[:5]
 
         # GH19018
         # initialization ordering: by insertion order if python>= 3.6
diff --git a/pandas/tests/groupby/aggregate/test_other.py b/pandas/tests/groupby/aggregate/test_other.py
index 398e9b09693e6..0596193c137e1 100644
--- a/pandas/tests/groupby/aggregate/test_other.py
+++ b/pandas/tests/groupby/aggregate/test_other.py
@@ -296,7 +296,9 @@ def raiseException(df):
 
 
 def test_series_agg_multikey():
-    ts = tm.makeTimeSeries()
+    ts = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
     grouped = ts.groupby([lambda x: x.year, lambda x: x.month])
 
     result = grouped.agg("sum")
diff --git a/pandas/tests/groupby/conftest.py b/pandas/tests/groupby/conftest.py
index 6d4a874f9d3ec..dce3f072ed903 100644
--- a/pandas/tests/groupby/conftest.py
+++ b/pandas/tests/groupby/conftest.py
@@ -4,9 +4,9 @@
 from pandas import (
     DataFrame,
     Index,
+    Series,
     date_range,
 )
-import pandas._testing as tm
 from pandas.core.groupby.base import (
     reduction_kernels,
     transformation_kernels,
@@ -47,7 +47,10 @@ def df():
 
 @pytest.fixture
 def ts():
-    return tm.makeTimeSeries()
+    return Series(
+        np.random.default_rng(2).standard_normal(30),
+        index=date_range("2000-01-01", periods=30, freq="B"),
+    )
 
 
 @pytest.fixture
diff --git a/pandas/tests/groupby/methods/test_describe.py b/pandas/tests/groupby/methods/test_describe.py
index ee8f93bf3b549..a2440e09dfc02 100644
--- a/pandas/tests/groupby/methods/test_describe.py
+++ b/pandas/tests/groupby/methods/test_describe.py
@@ -6,7 +6,9 @@
     DataFrame,
     Index,
     MultiIndex,
+    Series,
     Timestamp,
+    date_range,
 )
 import pandas._testing as tm
 
@@ -17,7 +19,9 @@ def test_apply_describe_bug(multiindex_dataframe_random_data):
 
 
 def test_series_describe_multikey():
-    ts = tm.makeTimeSeries()
+    ts = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
     grouped = ts.groupby([lambda x: x.year, lambda x: x.month])
     result = grouped.describe()
     tm.assert_series_equal(result["mean"], grouped.mean(), check_names=False)
@@ -26,7 +30,9 @@ def test_series_describe_multikey():
 
 
 def test_series_describe_single():
-    ts = tm.makeTimeSeries()
+    ts = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
     grouped = ts.groupby(lambda x: x.month)
     result = grouped.apply(lambda x: x.describe())
     expected = grouped.describe().stack(future_stack=True)
diff --git a/pandas/tests/io/formats/test_to_string.py b/pandas/tests/io/formats/test_to_string.py
index 02c20b0e25477..7cb7cbd223ac4 100644
--- a/pandas/tests/io/formats/test_to_string.py
+++ b/pandas/tests/io/formats/test_to_string.py
@@ -1075,7 +1075,10 @@ def test_to_string_timedelta64(self):
         assert result == "0   1 days\n1   2 days\n2   3 days"
 
     def test_to_string(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10, freq="B"),
+        )
         buf = StringIO()
 
         s = ts.to_string()
diff --git a/pandas/tests/io/json/test_pandas.py b/pandas/tests/io/json/test_pandas.py
index 428c73c282426..3982fd6c23d76 100644
--- a/pandas/tests/io/json/test_pandas.py
+++ b/pandas/tests/io/json/test_pandas.py
@@ -108,8 +108,11 @@ def categorical_frame(self):
     def datetime_series(self):
         # Same as usual datetime_series, but with index freq set to None,
         #  since that doesn't round-trip, see GH#33711
-        ser = tm.makeTimeSeries()
-        ser.name = "ts"
+        ser = Series(
+            1.1 * np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         ser.index = ser.index._with_freq(None)
         return ser
 
diff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py
index 6cb4a4ad47440..00a81a4f1f385 100644
--- a/pandas/tests/io/pytables/test_append.py
+++ b/pandas/tests/io/pytables/test_append.py
@@ -105,7 +105,9 @@ def test_append_series(setup_path):
     with ensure_clean_store(setup_path) as store:
         # basic
         ss = Series(range(20), dtype=np.float64, index=[f"i_{i}" for i in range(20)])
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         ns = Series(np.arange(100))
 
         store.append("ss", ss)
diff --git a/pandas/tests/io/pytables/test_file_handling.py b/pandas/tests/io/pytables/test_file_handling.py
index 40397c49f12d2..e292bc7fe251e 100644
--- a/pandas/tests/io/pytables/test_file_handling.py
+++ b/pandas/tests/io/pytables/test_file_handling.py
@@ -105,7 +105,9 @@ def test_reopen_handle(tmp_path, setup_path):
     path = tmp_path / setup_path
 
     store = HDFStore(path, mode="a")
-    store["a"] = tm.makeTimeSeries()
+    store["a"] = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
 
     msg = (
         r"Re-opening the file \[[\S]*\] with mode \[a\] will delete the "
@@ -126,7 +128,9 @@ def test_reopen_handle(tmp_path, setup_path):
     assert not store.is_open
 
     store = HDFStore(path, mode="a")
-    store["a"] = tm.makeTimeSeries()
+    store["a"] = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
 
     # reopen as read
     store.open("r")
@@ -179,7 +183,7 @@ def test_open_args(setup_path):
 
 def test_flush(setup_path):
     with ensure_clean_store(setup_path) as store:
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(range(5))
         store.flush()
         store.flush(fsync=True)
 
diff --git a/pandas/tests/io/pytables/test_keys.py b/pandas/tests/io/pytables/test_keys.py
index c0f2c34ff37ed..55bd3f0d5a03a 100644
--- a/pandas/tests/io/pytables/test_keys.py
+++ b/pandas/tests/io/pytables/test_keys.py
@@ -6,7 +6,7 @@
     HDFStore,
     Index,
     Series,
-    _testing as tm,
+    date_range,
 )
 from pandas.tests.io.pytables.common import (
     ensure_clean_store,
@@ -18,7 +18,9 @@
 
 def test_keys(setup_path):
     with ensure_clean_store(setup_path) as store:
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["b"] = Series(
             range(10), dtype="float64", index=[f"i_{i}" for i in range(10)]
         )
diff --git a/pandas/tests/io/pytables/test_put.py b/pandas/tests/io/pytables/test_put.py
index df47bd78c86b8..bc5f046b7fa33 100644
--- a/pandas/tests/io/pytables/test_put.py
+++ b/pandas/tests/io/pytables/test_put.py
@@ -96,7 +96,9 @@ def test_api_default_format(tmp_path, setup_path):
 
 def test_put(setup_path):
     with ensure_clean_store(setup_path) as store:
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         df = DataFrame(
             np.random.default_rng(2).standard_normal((20, 4)),
             columns=Index(list("ABCD"), dtype=object),
diff --git a/pandas/tests/io/pytables/test_round_trip.py b/pandas/tests/io/pytables/test_round_trip.py
index 2c61da3809010..4ba9787a5a6b9 100644
--- a/pandas/tests/io/pytables/test_round_trip.py
+++ b/pandas/tests/io/pytables/test_round_trip.py
@@ -34,7 +34,9 @@ def roundtrip(key, obj, **kwargs):
             obj.to_hdf(path, key=key, **kwargs)
             return read_hdf(path, key)
 
-        o = tm.makeTimeSeries()
+        o = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         tm.assert_series_equal(o, roundtrip("series", o))
 
         o = Series(range(10), dtype="float64", index=[f"i_{i}" for i in range(10)])
@@ -173,7 +175,9 @@ def test_api_invalid(tmp_path, setup_path):
 
 def test_get(setup_path):
     with ensure_clean_store(setup_path) as store:
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         left = store.get("a")
         right = store["a"]
         tm.assert_series_equal(left, right)
@@ -262,7 +266,9 @@ def test_series(setup_path):
     s = Series(range(10), dtype="float64", index=[f"i_{i}" for i in range(10)])
     _check_roundtrip(s, tm.assert_series_equal, path=setup_path)
 
-    ts = tm.makeTimeSeries()
+    ts = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
     _check_roundtrip(ts, tm.assert_series_equal, path=setup_path)
 
     ts2 = Series(ts.index, Index(ts.index, dtype=object))
@@ -538,7 +544,9 @@ def test_unicode_longer_encoded(setup_path):
 
 def test_store_datetime_mixed(setup_path):
     df = DataFrame({"a": [1, 2, 3], "b": [1.0, 2.0, 3.0], "c": ["a", "b", "c"]})
-    ts = tm.makeTimeSeries()
+    ts = Series(
+        np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+    )
     df["d"] = ts.index[:3]
     _check_roundtrip(df, tm.assert_frame_equal, path=setup_path)
 
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 057f1b1fd19c3..82d3052e7f5d6 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -107,7 +107,9 @@ def test_repr(setup_path):
     with ensure_clean_store(setup_path) as store:
         repr(store)
         store.info()
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["b"] = Series(
             range(10), dtype="float64", index=[f"i_{i}" for i in range(10)]
         )
@@ -162,7 +164,9 @@ def test_repr(setup_path):
 
 def test_contains(setup_path):
     with ensure_clean_store(setup_path) as store:
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["b"] = DataFrame(
             1.1 * np.arange(120).reshape((30, 4)),
             columns=Index(list("ABCD"), dtype=object),
@@ -195,7 +199,9 @@ def test_contains(setup_path):
 
 def test_versioning(setup_path):
     with ensure_clean_store(setup_path) as store:
-        store["a"] = tm.makeTimeSeries()
+        store["a"] = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["b"] = DataFrame(
             1.1 * np.arange(120).reshape((30, 4)),
             columns=Index(list("ABCD"), dtype=object),
@@ -290,7 +296,9 @@ def test_walk(where, expected):
 
 def test_getattr(setup_path):
     with ensure_clean_store(setup_path) as store:
-        s = tm.makeTimeSeries()
+        s = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["a"] = s
 
         # test attribute access
@@ -533,7 +541,9 @@ def test_calendar_roundtrip_issue(setup_path):
 
 def test_remove(setup_path):
     with ensure_clean_store(setup_path) as store:
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         df = DataFrame(
             1.1 * np.arange(120).reshape((30, 4)),
             columns=Index(list("ABCD"), dtype=object),
@@ -661,7 +671,9 @@ def test_overwrite_node(setup_path):
             columns=Index(list("ABCD"), dtype=object),
             index=date_range("2000-01-01", periods=10, freq="B"),
         )
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         store["a"] = ts
 
         tm.assert_series_equal(store["a"], ts)
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index e1fac21094139..4f3993a038197 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -586,7 +586,7 @@ def test_pickle_timeseries_periodindex():
     "name", [777, 777.0, "name", datetime.datetime(2001, 11, 11), (1, 2)]
 )
 def test_pickle_preserve_name(name):
-    unpickled = tm.round_trip_pickle(tm.makeTimeSeries(name=name))
+    unpickled = tm.round_trip_pickle(Series(np.arange(10, dtype=np.float64), name=name))
     assert unpickled.name == name
 
 
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index 401a7610b25d8..112172656b6ec 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -134,14 +134,18 @@ def test_tsplot_datetime(self, freq):
         _check_plot_works(ser.plot, ax=ax)
 
     def test_tsplot(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         _, ax = mpl.pyplot.subplots()
         ts.plot(style="k", ax=ax)
         color = (0.0, 0.0, 0.0, 1)
         assert color == ax.get_lines()[0].get_color()
 
     def test_both_style_and_color(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         msg = (
             "Cannot pass 'style' string with a color symbol and 'color' "
             "keyword argument. Please use one or the other or pass 'style' "
@@ -274,7 +278,9 @@ def test_fake_inferred_business(self):
         assert not hasattr(ax, "freq")
 
     def test_plot_offset_freq(self):
-        ser = tm.makeTimeSeries()
+        ser = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         _check_plot_works(ser.plot)
 
     def test_plot_offset_freq_business(self):
@@ -335,7 +341,9 @@ def test_irreg_hf_object(self):
         assert (np.fabs(diffs[1:] - sec) < 1e-8).all()
 
     def test_irregular_datetime64_repr_bug(self):
-        ser = tm.makeTimeSeries()
+        ser = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
         ser = ser.iloc[[0, 1, 2, 7]]
 
         _, ax = mpl.pyplot.subplots()
@@ -360,7 +368,10 @@ def test_business_freq(self):
             assert PeriodIndex(data=idx).freqstr == "B"
 
     def test_business_freq_convert(self):
-        bts = tm.makeTimeSeries(300).asfreq("BME")
+        bts = Series(
+            np.arange(300, dtype=np.float64),
+            index=date_range("2020-01-01", periods=300, freq="B"),
+        ).asfreq("BME")
         ts = bts.to_period("M")
         _, ax = mpl.pyplot.subplots()
         bts.plot(ax=ax)
@@ -371,7 +382,9 @@ def test_business_freq_convert(self):
     def test_freq_with_no_period_alias(self):
         # GH34487
         freq = WeekOfMonth()
-        bts = tm.makeTimeSeries(5).asfreq(freq)
+        bts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        ).asfreq(freq)
         _, ax = mpl.pyplot.subplots()
         bts.plot(ax=ax)
 
@@ -390,13 +403,18 @@ def test_nonzero_base(self):
         assert not Index(rs).is_normalized
 
     def test_dataframe(self):
-        bts = DataFrame({"a": tm.makeTimeSeries()})
+        bts = DataFrame(
+            {
+                "a": Series(
+                    np.arange(10, dtype=np.float64),
+                    index=date_range("2020-01-01", periods=10),
+                )
+            }
+        )
         _, ax = mpl.pyplot.subplots()
         bts.plot(ax=ax)
         idx = ax.get_lines()[0].get_xdata()
-        msg = r"PeriodDtype\[B\] is deprecated"
-        with tm.assert_produces_warning(FutureWarning, match=msg):
-            tm.assert_index_equal(bts.index.to_period(), PeriodIndex(idx))
+        tm.assert_index_equal(bts.index.to_period(), PeriodIndex(idx))
 
     @pytest.mark.filterwarnings(
         "ignore:Period with BDay freq is deprecated:FutureWarning"
@@ -404,8 +422,23 @@ def test_dataframe(self):
     @pytest.mark.parametrize(
         "obj",
         [
-            tm.makeTimeSeries(),
-            DataFrame({"a": tm.makeTimeSeries(), "b": tm.makeTimeSeries() + 1}),
+            Series(
+                np.arange(10, dtype=np.float64),
+                index=date_range("2020-01-01", periods=10),
+            ),
+            DataFrame(
+                {
+                    "a": Series(
+                        np.arange(10, dtype=np.float64),
+                        index=date_range("2020-01-01", periods=10),
+                    ),
+                    "b": Series(
+                        np.arange(10, dtype=np.float64),
+                        index=date_range("2020-01-01", periods=10),
+                    )
+                    + 1,
+                }
+            ),
         ],
     )
     def test_axis_limits(self, obj):
@@ -562,7 +595,9 @@ def test_finder_hourly(self):
         assert rs == xp
 
     def test_gaps(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
         ts.iloc[5:25] = np.nan
         _, ax = mpl.pyplot.subplots()
         ts.plot(ax=ax)
@@ -580,7 +615,9 @@ def test_gaps(self):
 
     def test_gaps_irregular(self):
         # irregular
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
         ts = ts.iloc[[0, 1, 2, 5, 7, 9, 12, 15, 20]]
         ts.iloc[2:5] = np.nan
         _, ax = mpl.pyplot.subplots()
@@ -615,7 +652,9 @@ def test_gaps_non_ts(self):
         assert mask[2:5, 1].all()
 
     def test_gap_upsample(self):
-        low = tm.makeTimeSeries()
+        low = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
         low.iloc[5:25] = np.nan
         _, ax = mpl.pyplot.subplots()
         low.plot(ax=ax)
@@ -734,7 +773,10 @@ def test_secondary_bar_frame(self):
 
     def test_mixed_freq_regular_first(self):
         # TODO
-        s1 = tm.makeTimeSeries()
+        s1 = Series(
+            np.arange(20, dtype=np.float64),
+            index=date_range("2020-01-01", periods=20, freq="B"),
+        )
         s2 = s1.iloc[[0, 5, 10, 11, 12, 13, 14, 15]]
 
         # it works!
@@ -757,7 +799,9 @@ def test_mixed_freq_regular_first(self):
         assert right >= pidx[-1].ordinal
 
     def test_mixed_freq_irregular_first(self):
-        s1 = tm.makeTimeSeries()
+        s1 = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        )
         s2 = s1.iloc[[0, 5, 10, 11, 12, 13, 14, 15]]
         _, ax = mpl.pyplot.subplots()
         s2.plot(style="g", ax=ax)
@@ -771,7 +815,10 @@ def test_mixed_freq_irregular_first(self):
 
     def test_mixed_freq_regular_first_df(self):
         # GH 9852
-        s1 = tm.makeTimeSeries().to_frame()
+        s1 = Series(
+            np.arange(20, dtype=np.float64),
+            index=date_range("2020-01-01", periods=20, freq="B"),
+        ).to_frame()
         s2 = s1.iloc[[0, 5, 10, 11, 12, 13, 14, 15], :]
         _, ax = mpl.pyplot.subplots()
         s1.plot(ax=ax)
@@ -790,7 +837,9 @@ def test_mixed_freq_regular_first_df(self):
 
     def test_mixed_freq_irregular_first_df(self):
         # GH 9852
-        s1 = tm.makeTimeSeries().to_frame()
+        s1 = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        ).to_frame()
         s2 = s1.iloc[[0, 5, 10, 11, 12, 13, 14, 15], :]
         _, ax = mpl.pyplot.subplots()
         s2.plot(style="g", ax=ax)
@@ -853,7 +902,9 @@ def test_mixed_freq_lf_first_hourly(self):
 
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_mixed_freq_irreg_period(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(30, dtype=np.float64), index=date_range("2020-01-01", periods=30)
+        )
         irreg = ts.iloc[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 18, 29]]
         msg = r"PeriodDtype\[B\] is deprecated"
         with tm.assert_produces_warning(FutureWarning, match=msg):
@@ -1417,7 +1468,9 @@ def test_irregular_ts_shared_ax_xlim(self):
         # GH 2960
         from pandas.plotting._matplotlib.converter import DatetimeConverter
 
-        ts = tm.makeTimeSeries()[:20]
+        ts = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        )
         ts_irregular = ts.iloc[[1, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 17, 18]]
 
         # plot the left section of the irregular series, then the right section
@@ -1481,7 +1534,9 @@ def test_secondary_y_irregular_ts_xlim(self):
         # GH 3490 - irregular-timeseries with secondary y
         from pandas.plotting._matplotlib.converter import DatetimeConverter
 
-        ts = tm.makeTimeSeries()[:20]
+        ts = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        )
         ts_irregular = ts.iloc[[1, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 17, 18]]
 
         _, ax = mpl.pyplot.subplots()
diff --git a/pandas/tests/plotting/test_hist_method.py b/pandas/tests/plotting/test_hist_method.py
index e38cd696a2d90..4d17f87fdc7bc 100644
--- a/pandas/tests/plotting/test_hist_method.py
+++ b/pandas/tests/plotting/test_hist_method.py
@@ -8,6 +8,7 @@
     DataFrame,
     Index,
     Series,
+    date_range,
     to_datetime,
 )
 import pandas._testing as tm
@@ -29,7 +30,11 @@
 
 @pytest.fixture
 def ts():
-    return tm.makeTimeSeries(name="ts")
+    return Series(
+        np.arange(30, dtype=np.float64),
+        index=date_range("2020-01-01", periods=30, freq="B"),
+        name="ts",
+    )
 
 
 class TestSeriesPlots:
diff --git a/pandas/tests/plotting/test_misc.py b/pandas/tests/plotting/test_misc.py
index 56028249fe517..cfb657c2a800f 100644
--- a/pandas/tests/plotting/test_misc.py
+++ b/pandas/tests/plotting/test_misc.py
@@ -110,7 +110,11 @@ class TestSeriesPlots:
     def test_autocorrelation_plot(self):
         from pandas.plotting import autocorrelation_plot
 
-        ser = tm.makeTimeSeries(name="ts")
+        ser = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         # Ensure no UserWarning when making plot
         with tm.assert_produces_warning(None):
             _check_plot_works(autocorrelation_plot, series=ser)
@@ -123,13 +127,21 @@ def test_autocorrelation_plot(self):
     def test_lag_plot(self, kwargs):
         from pandas.plotting import lag_plot
 
-        ser = tm.makeTimeSeries(name="ts")
+        ser = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         _check_plot_works(lag_plot, series=ser, **kwargs)
 
     def test_bootstrap_plot(self):
         from pandas.plotting import bootstrap_plot
 
-        ser = tm.makeTimeSeries(name="ts")
+        ser = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         _check_plot_works(bootstrap_plot, series=ser, size=10)
 
 
diff --git a/pandas/tests/plotting/test_series.py b/pandas/tests/plotting/test_series.py
index 9bf76637e1d71..2b2f2f3b84307 100644
--- a/pandas/tests/plotting/test_series.py
+++ b/pandas/tests/plotting/test_series.py
@@ -38,7 +38,11 @@
 
 @pytest.fixture
 def ts():
-    return tm.makeTimeSeries(name="ts")
+    return Series(
+        np.arange(10, dtype=np.float64),
+        index=date_range("2020-01-01", periods=10),
+        name="ts",
+    )
 
 
 @pytest.fixture
diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py
index ccfa3be702dae..30ec0d0affaa3 100644
--- a/pandas/tests/reductions/test_reductions.py
+++ b/pandas/tests/reductions/test_reductions.py
@@ -949,7 +949,11 @@ def test_idxmax(self):
         assert result == 1.1
 
     def test_all_any(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         bool_series = ts > 0
         assert not bool_series.all()
         assert bool_series.any()
diff --git a/pandas/tests/reductions/test_stat_reductions.py b/pandas/tests/reductions/test_stat_reductions.py
index 844c49e6a41a4..a94ed0e044598 100644
--- a/pandas/tests/reductions/test_stat_reductions.py
+++ b/pandas/tests/reductions/test_stat_reductions.py
@@ -10,6 +10,7 @@
 from pandas import (
     DataFrame,
     Series,
+    date_range,
 )
 import pandas._testing as tm
 from pandas.core.arrays import (
@@ -24,7 +25,7 @@ class TestDatetimeLikeStatReductions:
     def test_dt64_mean(self, tz_naive_fixture, box):
         tz = tz_naive_fixture
 
-        dti = pd.date_range("2001-01-01", periods=11, tz=tz)
+        dti = date_range("2001-01-01", periods=11, tz=tz)
         # shuffle so that we are not just working with monotone-increasing
         dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
         dtarr = dti._data
@@ -44,7 +45,7 @@ def test_dt64_mean(self, tz_naive_fixture, box):
     @pytest.mark.parametrize("freq", ["s", "h", "D", "W", "B"])
     def test_period_mean(self, box, freq):
         # GH#24757
-        dti = pd.date_range("2001-01-01", periods=11)
+        dti = date_range("2001-01-01", periods=11)
         # shuffle so that we are not just working with monotone-increasing
         dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
 
@@ -104,7 +105,7 @@ def _check_stat_op(
 
             # mean, idxmax, idxmin, min, and max are valid for dates
             if name not in ["max", "min", "mean", "median", "std"]:
-                ds = Series(pd.date_range("1/1/2001", periods=10))
+                ds = Series(date_range("1/1/2001", periods=10))
                 msg = f"does not support reduction '{name}'"
                 with pytest.raises(TypeError, match=msg):
                     f(ds)
@@ -184,7 +185,11 @@ def test_max(self):
 
     def test_var_std(self):
         string_series = Series(range(20), dtype=np.float64, name="series")
-        datetime_series = tm.makeTimeSeries().rename("ts")
+        datetime_series = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
 
         alt = lambda x: np.std(x, ddof=1)
         self._check_stat_op("std", alt, string_series)
@@ -210,7 +215,11 @@ def test_var_std(self):
 
     def test_sem(self):
         string_series = Series(range(20), dtype=np.float64, name="series")
-        datetime_series = tm.makeTimeSeries().rename("ts")
+        datetime_series = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
 
         alt = lambda x: np.std(x, ddof=1) / np.sqrt(len(x))
         self._check_stat_op("sem", alt, string_series)
diff --git a/pandas/tests/resample/test_resampler_grouper.py b/pandas/tests/resample/test_resampler_grouper.py
index 3cf5201d573d4..337c5ff53bd14 100644
--- a/pandas/tests/resample/test_resampler_grouper.py
+++ b/pandas/tests/resample/test_resampler_grouper.py
@@ -30,8 +30,11 @@ def test_tab_complete_ipython6_warning(ip):
 
     code = dedent(
         """\
-    import pandas._testing as tm
-    s = tm.makeTimeSeries()
+    import numpy as np
+    from pandas import Series, date_range
+    data = np.arange(10, dtype=np.float64)
+    index = date_range("2020-01-01", periods=len(data))
+    s = Series(data, index=index)
     rs = s.resample("D")
     """
     )
diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py
index ed111ff4e0ee1..ea0d510d2b8f8 100644
--- a/pandas/tests/reshape/concat/test_concat.py
+++ b/pandas/tests/reshape/concat/test_concat.py
@@ -387,8 +387,10 @@ def test_concat_keys_with_none(self):
         tm.assert_frame_equal(result, expected)
 
     def test_concat_bug_1719(self):
-        ts1 = tm.makeTimeSeries()
-        ts2 = tm.makeTimeSeries()[::2]
+        ts1 = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
+        ts2 = ts1.copy()[::2]
 
         # to join with union
         # these two are of different length!
diff --git a/pandas/tests/reshape/concat/test_series.py b/pandas/tests/reshape/concat/test_series.py
index 4bef86ce6a941..c12b835cb61e1 100644
--- a/pandas/tests/reshape/concat/test_series.py
+++ b/pandas/tests/reshape/concat/test_series.py
@@ -15,7 +15,11 @@
 
 class TestSeriesConcat:
     def test_concat_series(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(20, dtype=np.float64),
+            index=date_range("2020-01-01", periods=20),
+            name="foo",
+        )
         ts.name = "foo"
 
         pieces = [ts[:5], ts[5:15], ts[15:]]
@@ -46,7 +50,9 @@ def test_concat_empty_and_non_empty_series_regression(self):
         tm.assert_series_equal(result, expected)
 
     def test_concat_series_axis1(self):
-        ts = tm.makeTimeSeries()
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
 
         pieces = [ts[:-2], ts[2:], ts[2:-2]]
 
diff --git a/pandas/tests/series/methods/test_cov_corr.py b/pandas/tests/series/methods/test_cov_corr.py
index a8bc44dfd9ca4..a369145b4e884 100644
--- a/pandas/tests/series/methods/test_cov_corr.py
+++ b/pandas/tests/series/methods/test_cov_corr.py
@@ -6,6 +6,7 @@
 import pandas as pd
 from pandas import (
     Series,
+    date_range,
     isna,
 )
 import pandas._testing as tm
@@ -81,8 +82,12 @@ def test_corr(self, datetime_series, dtype):
         cp[:] = np.nan
         assert isna(cp.corr(cp))
 
-        A = tm.makeTimeSeries()
-        B = tm.makeTimeSeries()
+        A = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
+        B = A.copy()
         result = A.corr(B)
         expected, _ = stats.pearsonr(A, B)
         tm.assert_almost_equal(result, expected)
@@ -91,8 +96,12 @@ def test_corr_rank(self):
         stats = pytest.importorskip("scipy.stats")
 
         # kendall and spearman
-        A = tm.makeTimeSeries()
-        B = tm.makeTimeSeries()
+        A = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
+        B = A.copy()
         A[-5:] = A[:5].copy()
         result = A.corr(B, method="kendall")
         expected = stats.kendalltau(A, B)[0]
diff --git a/pandas/tests/series/methods/test_diff.py b/pandas/tests/series/methods/test_diff.py
index 938a0f9ac49d1..18de81a927c3a 100644
--- a/pandas/tests/series/methods/test_diff.py
+++ b/pandas/tests/series/methods/test_diff.py
@@ -31,7 +31,11 @@ def test_diff_int(self):
 
     def test_diff_tz(self):
         # Combined datetime diff, normal diff and boolean diff test
-        ts = tm.makeTimeSeries(name="ts")
+        ts = Series(
+            np.arange(10, dtype=np.float64),
+            index=date_range("2020-01-01", periods=10),
+            name="ts",
+        )
         ts.diff()
 
         # neg n
diff --git a/pandas/tests/series/methods/test_map.py b/pandas/tests/series/methods/test_map.py
index 7b14e1289abf0..251d4063008b9 100644
--- a/pandas/tests/series/methods/test_map.py
+++ b/pandas/tests/series/methods/test_map.py
@@ -15,6 +15,7 @@
     MultiIndex,
     Series,
     bdate_range,
+    date_range,
     isna,
     timedelta_range,
 )
@@ -74,7 +75,7 @@ def f(x):
 
 def test_series_map_box_timestamps():
     # GH#2689, GH#2627
-    ser = Series(pd.date_range("1/1/2000", periods=3))
+    ser = Series(date_range("1/1/2000", periods=3))
 
     def func(x):
         return (x.hour, x.day, x.month)
@@ -132,7 +133,7 @@ def test_map_empty_integer_series():
 
 def test_map_empty_integer_series_with_datetime_index():
     # GH 21245
-    s = Series([], index=pd.date_range(start="2018-01-01", periods=0), dtype=int)
+    s = Series([], index=date_range(start="2018-01-01", periods=0), dtype=int)
     result = s.map(lambda x: x)
     tm.assert_series_equal(result, s)
 
@@ -522,14 +523,12 @@ def test_map_categorical_na_action(na_action, expected):
 
 
 def test_map_datetimetz():
-    values = pd.date_range("2011-01-01", "2011-01-02", freq="h").tz_localize(
-        "Asia/Tokyo"
-    )
+    values = date_range("2011-01-01", "2011-01-02", freq="h").tz_localize("Asia/Tokyo")
     s = Series(values, name="XX")
 
     # keep tz
     result = s.map(lambda x: x + pd.offsets.Day())
-    exp_values = pd.date_range("2011-01-02", "2011-01-03", freq="h").tz_localize(
+    exp_values = date_range("2011-01-02", "2011-01-03", freq="h").tz_localize(
         "Asia/Tokyo"
     )
     exp = Series(exp_values, name="XX")
@@ -571,9 +570,13 @@ def test_map_missing_mixed(vals, mapping, exp, using_infer_string):
 def test_map_scalar_on_date_time_index_aware_series():
     # GH 25959
     # Calling map on a localized time series should not cause an error
-    series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
+    series = Series(
+        np.arange(10, dtype=np.float64),
+        index=date_range("2020-01-01", periods=10, tz="UTC"),
+        name="ts",
+    )
     result = Series(series.index).map(lambda x: 1)
-    tm.assert_series_equal(result, Series(np.ones(30), dtype="int64"))
+    tm.assert_series_equal(result, Series(np.ones(len(series)), dtype="int64"))
 
 
 def test_map_float_to_string_precision():
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index f38a29bfe7e88..75237be212030 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -59,7 +59,11 @@ class TestSeriesFlexArithmetic:
     )
     def test_flex_method_equivalence(self, opname, ts):
         # check that Series.{opname} behaves like Series.__{opname}__,
-        tser = tm.makeTimeSeries().rename("ts")
+        tser = Series(
+            np.arange(20, dtype=np.float64),
+            index=date_range("2020-01-01", periods=20),
+            name="ts",
+        )
 
         series = ts[0](tser)
         other = ts[1](tser)
diff --git a/pandas/tests/series/test_formats.py b/pandas/tests/series/test_formats.py
index 040b1186980b2..a1c5018ea7961 100644
--- a/pandas/tests/series/test_formats.py
+++ b/pandas/tests/series/test_formats.py
@@ -218,7 +218,9 @@ def test_timeseries_repr_object_dtype(self):
         ts = Series(np.random.default_rng(2).standard_normal(len(index)), index)
         repr(ts)
 
-        ts = tm.makeTimeSeries(1000)
+        ts = Series(
+            np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+        )
         assert repr(ts).splitlines()[-1].startswith("Freq:")
 
         ts2 = ts.iloc[np.random.default_rng(2).integers(0, len(ts) - 1, 400)]
diff --git a/pandas/tests/window/test_pairwise.py b/pandas/tests/window/test_pairwise.py
index 2258a4106fe92..3ceb58756bac6 100644
--- a/pandas/tests/window/test_pairwise.py
+++ b/pandas/tests/window/test_pairwise.py
@@ -62,9 +62,13 @@ def test_rolling_corr(series):
     result = A.rolling(window=50, min_periods=25).corr(B)
     tm.assert_almost_equal(result.iloc[-1], np.corrcoef(A[-50:], B[-50:])[0, 1])
 
+
+def test_rolling_corr_bias_correction():
     # test for correct bias correction
-    a = tm.makeTimeSeries()
-    b = tm.makeTimeSeries()
+    a = Series(
+        np.arange(20, dtype=np.float64), index=date_range("2020-01-01", periods=20)
+    )
+    b = a.copy()
     a[:5] = np.nan
     b[:10] = np.nan