diff --git a/pandas/tests/frame/methods/test_set_index.py b/pandas/tests/frame/methods/test_set_index.py
index 98113b6c41821..d958c80fbcdef 100644
--- a/pandas/tests/frame/methods/test_set_index.py
+++ b/pandas/tests/frame/methods/test_set_index.py
@@ -155,7 +155,11 @@ def test_set_index(self, float_string_frame):
             df.set_index(idx[::2])
 
     def test_set_index_names(self):
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            np.ones((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(10)], dtype=object),
+        )
         df.index.name = "name"
 
         assert df.set_index(df.index).index.names == ["name"]
diff --git a/pandas/tests/frame/test_arithmetic.py b/pandas/tests/frame/test_arithmetic.py
index 8083795a69413..7fd795dc84cca 100644
--- a/pandas/tests/frame/test_arithmetic.py
+++ b/pandas/tests/frame/test_arithmetic.py
@@ -1566,7 +1566,10 @@ def test_strings_to_numbers_comparisons_raises(self, compare_operators_no_eq_ne)
             f(df, 0)
 
     def test_comparison_protected_from_errstate(self):
-        missing_df = tm.makeDataFrame()
+        missing_df = DataFrame(
+            np.ones((10, 4), dtype=np.float64),
+            columns=Index(list("ABCD"), dtype=object),
+        )
         missing_df.loc[missing_df.index[0], "A"] = np.nan
         with np.errstate(invalid="ignore"):
             expected = missing_df.values < 0
diff --git a/pandas/tests/indexing/test_chaining_and_caching.py b/pandas/tests/indexing/test_chaining_and_caching.py
index bf0975a803dce..73ac9a3bb1a44 100644
--- a/pandas/tests/indexing/test_chaining_and_caching.py
+++ b/pandas/tests/indexing/test_chaining_and_caching.py
@@ -12,6 +12,7 @@
 import pandas as pd
 from pandas import (
     DataFrame,
+    Index,
     Series,
     Timestamp,
     date_range,
@@ -627,7 +628,10 @@ def test_chained_getitem_with_lists(self):
     def test_cache_updating(self):
         # GH 4939, make sure to update the cache on setitem
 
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            np.zeros((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+        )
         df["A"]  # cache series
         df.loc["Hello Friend"] = df.iloc[0]
         assert "Hello Friend" in df["A"].index
diff --git a/pandas/tests/io/excel/test_writers.py b/pandas/tests/io/excel/test_writers.py
index 507d7ed4bf9d0..9aeac58de50bb 100644
--- a/pandas/tests/io/excel/test_writers.py
+++ b/pandas/tests/io/excel/test_writers.py
@@ -1234,7 +1234,11 @@ def test_freeze_panes(self, path):
         tm.assert_frame_equal(result, expected)
 
     def test_path_path_lib(self, engine, ext):
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         writer = partial(df.to_excel, engine=engine)
 
         reader = partial(pd.read_excel, index_col=0)
@@ -1242,7 +1246,11 @@ def test_path_path_lib(self, engine, ext):
         tm.assert_frame_equal(result, df)
 
     def test_path_local_path(self, engine, ext):
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         writer = partial(df.to_excel, engine=engine)
 
         reader = partial(pd.read_excel, index_col=0)
diff --git a/pandas/tests/io/formats/test_to_csv.py b/pandas/tests/io/formats/test_to_csv.py
index 613f609320f31..33b9fe9b665f3 100644
--- a/pandas/tests/io/formats/test_to_csv.py
+++ b/pandas/tests/io/formats/test_to_csv.py
@@ -10,6 +10,7 @@
 import pandas as pd
 from pandas import (
     DataFrame,
+    Index,
     compat,
 )
 import pandas._testing as tm
@@ -665,7 +666,7 @@ def test_na_rep_truncated(self):
     def test_to_csv_errors(self, errors):
         # GH 22610
         data = ["\ud800foo"]
-        ser = pd.Series(data, index=pd.Index(data))
+        ser = pd.Series(data, index=Index(data))
         with tm.ensure_clean("test.csv") as path:
             ser.to_csv(path, errors=errors)
         # No use in reading back the data as it is not the same anymore
@@ -679,7 +680,11 @@ def test_to_csv_binary_handle(self, mode):
 
         GH 35058 and GH 19827
         """
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         with tm.ensure_clean() as path:
             with open(path, mode="w+b") as handle:
                 df.to_csv(handle, mode=mode)
@@ -713,7 +718,11 @@ def test_to_csv_encoding_binary_handle(self, mode):
 
 def test_to_csv_iterative_compression_name(compression):
     # GH 38714
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     with tm.ensure_clean() as path:
         df.to_csv(path, compression=compression, chunksize=1)
         tm.assert_frame_equal(
@@ -723,7 +732,11 @@ def test_to_csv_iterative_compression_name(compression):
 
 def test_to_csv_iterative_compression_buffer(compression):
     # GH 38714
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     with io.BytesIO() as buffer:
         df.to_csv(buffer, compression=compression, chunksize=1)
         buffer.seek(0)
diff --git a/pandas/tests/io/parser/common/test_file_buffer_url.py b/pandas/tests/io/parser/common/test_file_buffer_url.py
index c374795019ff4..a7a8d031da215 100644
--- a/pandas/tests/io/parser/common/test_file_buffer_url.py
+++ b/pandas/tests/io/parser/common/test_file_buffer_url.py
@@ -11,6 +11,7 @@
 from urllib.error import URLError
 import uuid
 
+import numpy as np
 import pytest
 
 from pandas.errors import (
@@ -19,7 +20,10 @@
 )
 import pandas.util._test_decorators as td
 
-from pandas import DataFrame
+from pandas import (
+    DataFrame,
+    Index,
+)
 import pandas._testing as tm
 
 pytestmark = pytest.mark.filterwarnings(
@@ -66,7 +70,11 @@ def test_local_file(all_parsers, csv_dir_path):
 @xfail_pyarrow  # AssertionError: DataFrame.index are different
 def test_path_path_lib(all_parsers):
     parser = all_parsers
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     result = tm.round_trip_pathlib(df.to_csv, lambda p: parser.read_csv(p, index_col=0))
     tm.assert_frame_equal(df, result)
 
@@ -74,7 +82,11 @@ def test_path_path_lib(all_parsers):
 @xfail_pyarrow  # AssertionError: DataFrame.index are different
 def test_path_local_path(all_parsers):
     parser = all_parsers
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     result = tm.round_trip_localpath(
         df.to_csv, lambda p: parser.read_csv(p, index_col=0)
     )
diff --git a/pandas/tests/io/pytables/test_append.py b/pandas/tests/io/pytables/test_append.py
index 89a0162af1c54..9eb9ffa53dd22 100644
--- a/pandas/tests/io/pytables/test_append.py
+++ b/pandas/tests/io/pytables/test_append.py
@@ -11,6 +11,7 @@
 import pandas as pd
 from pandas import (
     DataFrame,
+    Index,
     Series,
     _testing as tm,
     concat,
@@ -401,7 +402,7 @@ def check_col(key, name, size):
             {
                 "A": [0.0, 1.0, 2.0, 3.0, 4.0],
                 "B": [0.0, 1.0, 0.0, 1.0, 0.0],
-                "C": pd.Index(["foo1", "foo2", "foo3", "foo4", "foo5"], dtype=object),
+                "C": Index(["foo1", "foo2", "foo3", "foo4", "foo5"], dtype=object),
                 "D": date_range("20130101", periods=5),
             }
         ).set_index("C")
@@ -658,7 +659,11 @@ def test_append_hierarchical(tmp_path, setup_path, multiindex_dataframe_random_d
 
 def test_append_misc(setup_path):
     with ensure_clean_store(setup_path) as store:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         store.append("df", df, chunksize=1)
         result = store.select("df")
         tm.assert_frame_equal(result, df)
@@ -671,7 +676,11 @@ def test_append_misc(setup_path):
 @pytest.mark.parametrize("chunksize", [10, 200, 1000])
 def test_append_misc_chunksize(setup_path, chunksize):
     # more chunksize in append tests
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df["string"] = "foo"
     df["float322"] = 1.0
     df["float322"] = df["float322"].astype("float32")
@@ -715,7 +724,11 @@ def test_append_raise(setup_path):
         # test append with invalid input to get good error messages
 
         # list in column
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df["invalid"] = [["a"]] * len(df)
         assert df.dtypes["invalid"] == np.object_
         msg = re.escape(
@@ -732,7 +745,11 @@ def test_append_raise(setup_path):
             store.append("df", df)
 
         # datetime with embedded nans as object
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         s = Series(datetime.datetime(2001, 1, 2), index=df.index)
         s = s.astype(object)
         s[0:5] = np.nan
@@ -756,7 +773,11 @@ def test_append_raise(setup_path):
             store.append("df", Series(np.arange(10)))
 
         # appending an incompatible table
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         store.append("df", df)
 
         df["foo"] = "foo"
diff --git a/pandas/tests/io/pytables/test_errors.py b/pandas/tests/io/pytables/test_errors.py
index adf42cc7e8d39..d956e4f5775eb 100644
--- a/pandas/tests/io/pytables/test_errors.py
+++ b/pandas/tests/io/pytables/test_errors.py
@@ -9,6 +9,7 @@
     CategoricalIndex,
     DataFrame,
     HDFStore,
+    Index,
     MultiIndex,
     _testing as tm,
     date_range,
@@ -25,7 +26,11 @@
 
 
 def test_pass_spec_to_storer(setup_path):
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     with ensure_clean_store(setup_path) as store:
         store.put("df", df)
@@ -60,14 +65,22 @@ def test_unimplemented_dtypes_table_columns(setup_path):
 
         # currently not supported dtypes ####
         for n, f in dtypes:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
             df[n] = f
             msg = re.escape(f"[{n}] is not implemented as a table column")
             with pytest.raises(TypeError, match=msg):
                 store.append(f"df1_{n}", df)
 
     # frame
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df["obj1"] = "foo"
     df["obj2"] = "bar"
     df["datetime1"] = datetime.date(2001, 1, 2)
diff --git a/pandas/tests/io/pytables/test_file_handling.py b/pandas/tests/io/pytables/test_file_handling.py
index cb44512d4506c..2920f0b07b31e 100644
--- a/pandas/tests/io/pytables/test_file_handling.py
+++ b/pandas/tests/io/pytables/test_file_handling.py
@@ -17,6 +17,7 @@
 from pandas import (
     DataFrame,
     HDFStore,
+    Index,
     Series,
     _testing as tm,
     read_hdf,
@@ -145,7 +146,11 @@ def test_reopen_handle(tmp_path, setup_path):
 
 def test_open_args(setup_path):
     with tm.ensure_clean(setup_path) as path:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
 
         # create an in memory store
         store = HDFStore(
@@ -172,7 +177,11 @@ def test_flush(setup_path):
 
 def test_complibs_default_settings(tmp_path, setup_path):
     # GH15943
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     # Set complevel and check if complib is automatically set to
     # default value
@@ -211,7 +220,11 @@ def test_complibs_default_settings(tmp_path, setup_path):
 
 def test_complibs_default_settings_override(tmp_path, setup_path):
     # Check if file-defaults can be overridden on a per table basis
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     tmpfile = tmp_path / setup_path
     store = HDFStore(tmpfile)
     store.append("dfc", df, complevel=9, complib="blosc")
@@ -325,7 +338,11 @@ def test_multiple_open_close(tmp_path, setup_path):
 
     path = tmp_path / setup_path
 
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df.to_hdf(path, key="df", mode="w", format="table")
 
     # single
@@ -402,7 +419,11 @@ def test_multiple_open_close(tmp_path, setup_path):
     # ops on a closed store
     path = tmp_path / setup_path
 
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df.to_hdf(path, key="df", mode="w", format="table")
 
     store = HDFStore(path)
diff --git a/pandas/tests/io/pytables/test_keys.py b/pandas/tests/io/pytables/test_keys.py
index fd7df29595090..c0f2c34ff37ed 100644
--- a/pandas/tests/io/pytables/test_keys.py
+++ b/pandas/tests/io/pytables/test_keys.py
@@ -1,8 +1,10 @@
+import numpy as np
 import pytest
 
 from pandas import (
     DataFrame,
     HDFStore,
+    Index,
     Series,
     _testing as tm,
 )
@@ -20,7 +22,11 @@ def test_keys(setup_path):
         store["b"] = Series(
             range(10), dtype="float64", index=[f"i_{i}" for i in range(10)]
         )
-        store["c"] = tm.makeDataFrame()
+        store["c"] = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
 
         assert len(store) == 3
         expected = {"/a", "/b", "/c"}
diff --git a/pandas/tests/io/pytables/test_put.py b/pandas/tests/io/pytables/test_put.py
index 59a05dc9ea546..8a6e3c9006439 100644
--- a/pandas/tests/io/pytables/test_put.py
+++ b/pandas/tests/io/pytables/test_put.py
@@ -47,7 +47,11 @@ def test_format_kwarg_in_constructor(tmp_path, setup_path):
 def test_api_default_format(tmp_path, setup_path):
     # default_format option
     with ensure_clean_store(setup_path) as store:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
 
         with pd.option_context("io.hdf.default_format", "fixed"):
             _maybe_remove(store, "df")
@@ -68,7 +72,11 @@ def test_api_default_format(tmp_path, setup_path):
             assert store.get_storer("df").is_table
 
     path = tmp_path / setup_path
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     with pd.option_context("io.hdf.default_format", "fixed"):
         df.to_hdf(path, key="df")
diff --git a/pandas/tests/io/pytables/test_round_trip.py b/pandas/tests/io/pytables/test_round_trip.py
index e05e1e96eb11f..693f10172a99e 100644
--- a/pandas/tests/io/pytables/test_round_trip.py
+++ b/pandas/tests/io/pytables/test_round_trip.py
@@ -39,7 +39,11 @@ def roundtrip(key, obj, **kwargs):
         o = Series(range(10), dtype="float64", index=[f"i_{i}" for i in range(10)])
         tm.assert_series_equal(o, roundtrip("string_series", o))
 
-        o = tm.makeDataFrame()
+        o = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         tm.assert_frame_equal(o, roundtrip("frame", o))
 
         # table
@@ -136,7 +140,11 @@ def test_api_2(tmp_path, setup_path):
 def test_api_invalid(tmp_path, setup_path):
     path = tmp_path / setup_path
     # Invalid.
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     msg = "Can only append to Tables"
 
@@ -347,7 +355,11 @@ def test_timeseries_preepoch(setup_path, request):
     "compression", [False, pytest.param(True, marks=td.skip_if_windows)]
 )
 def test_frame(compression, setup_path):
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     # put in some random NAs
     df.iloc[0, 0] = np.nan
@@ -424,7 +436,11 @@ def test_store_hierarchical(setup_path, multiindex_dataframe_random_data):
 )
 def test_store_mixed(compression, setup_path):
     def _make_one():
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df["obj1"] = "foo"
         df["obj2"] = "bar"
         df["bool1"] = df["A"] > 0
diff --git a/pandas/tests/io/pytables/test_select.py b/pandas/tests/io/pytables/test_select.py
index e387b1b607f63..3eaa1e86dbf6d 100644
--- a/pandas/tests/io/pytables/test_select.py
+++ b/pandas/tests/io/pytables/test_select.py
@@ -266,7 +266,11 @@ def test_select_dtypes(setup_path):
     # test selection with comparison against numpy scalar
     # GH 11283
     with ensure_clean_store(setup_path) as store:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
 
         expected = df[df["A"] > 0]
 
diff --git a/pandas/tests/io/pytables/test_store.py b/pandas/tests/io/pytables/test_store.py
index 7e8365a8f9ffa..98257f1765d53 100644
--- a/pandas/tests/io/pytables/test_store.py
+++ b/pandas/tests/io/pytables/test_store.py
@@ -45,7 +45,11 @@ def test_context(setup_path):
             pass
     with tm.ensure_clean(setup_path) as path:
         with HDFStore(path) as tbl:
-            tbl["a"] = tm.makeDataFrame()
+            tbl["a"] = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
             assert len(tbl) == 1
             assert type(tbl["a"]) == DataFrame
 
@@ -107,9 +111,17 @@ def test_repr(setup_path):
         store["b"] = Series(
             range(10), dtype="float64", index=[f"i_{i}" for i in range(10)]
         )
-        store["c"] = tm.makeDataFrame()
+        store["c"] = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
 
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df["obj1"] = "foo"
         df["obj2"] = "bar"
         df["bool1"] = df["A"] > 0
@@ -136,7 +148,11 @@ def test_repr(setup_path):
 
     # storers
     with ensure_clean_store(setup_path) as store:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         store.append("df", df)
 
         s = store.get_storer("df")
@@ -147,8 +163,16 @@ def test_repr(setup_path):
 def test_contains(setup_path):
     with ensure_clean_store(setup_path) as store:
         store["a"] = tm.makeTimeSeries()
-        store["b"] = tm.makeDataFrame()
-        store["foo/bar"] = tm.makeDataFrame()
+        store["b"] = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        store["foo/bar"] = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         assert "a" in store
         assert "b" in store
         assert "c" not in store
@@ -161,14 +185,22 @@ def test_contains(setup_path):
         with tm.assert_produces_warning(
             tables.NaturalNameWarning, check_stacklevel=False
         ):
-            store["node())"] = tm.makeDataFrame()
+            store["node())"] = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
         assert "node())" in store
 
 
 def test_versioning(setup_path):
     with ensure_clean_store(setup_path) as store:
         store["a"] = tm.makeTimeSeries()
-        store["b"] = tm.makeDataFrame()
+        store["b"] = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df = tm.makeTimeDataFrame()
         _maybe_remove(store, "df1")
         store.append("df1", df[:10])
@@ -432,7 +464,11 @@ def test_mi_data_columns(setup_path):
 
 def test_table_mixed_dtypes(setup_path):
     # frame
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df["obj1"] = "foo"
     df["obj2"] = "bar"
     df["bool1"] = df["A"] > 0
@@ -482,7 +518,11 @@ def test_calendar_roundtrip_issue(setup_path):
 def test_remove(setup_path):
     with ensure_clean_store(setup_path) as store:
         ts = tm.makeTimeSeries()
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         store["a"] = ts
         store["b"] = df
         _maybe_remove(store, "a")
@@ -542,7 +582,11 @@ def test_same_name_scoping(setup_path):
 
 
 def test_store_index_name(setup_path):
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     df.index.name = "foo"
 
     with ensure_clean_store(setup_path) as store:
@@ -581,7 +625,11 @@ def test_store_index_name_numpy_str(tmp_path, table_format, setup_path, unit, tz
 
 
 def test_store_series_name(setup_path):
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     series = df["A"]
 
     with ensure_clean_store(setup_path) as store:
@@ -783,7 +831,11 @@ def test_start_stop_fixed(setup_path):
         tm.assert_series_equal(result, expected)
 
         # sparse; not implemented
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.iloc[3:5, 1:3] = np.nan
         df.iloc[8:10, -2] = np.nan
 
@@ -806,7 +858,11 @@ def test_select_filter_corner(setup_path):
 
 
 def test_path_pathlib():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     result = tm.round_trip_pathlib(
         lambda p: df.to_hdf(p, key="df"), lambda p: read_hdf(p, "df")
@@ -832,7 +888,11 @@ def test_contiguous_mixed_data_table(start, stop, setup_path):
 
 
 def test_path_pathlib_hdfstore():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     def writer(path):
         with HDFStore(path) as store:
@@ -847,7 +907,11 @@ def reader(path):
 
 
 def test_pickle_path_localpath():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     result = tm.round_trip_pathlib(
         lambda p: df.to_hdf(p, key="df"), lambda p: read_hdf(p, "df")
     )
@@ -855,7 +919,11 @@ def test_pickle_path_localpath():
 
 
 def test_path_localpath_hdfstore():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     def writer(path):
         with HDFStore(path) as store:
@@ -871,7 +939,11 @@ def reader(path):
 
 @pytest.mark.parametrize("propindexes", [True, False])
 def test_copy(propindexes):
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     with tm.ensure_clean() as path:
         with HDFStore(path) as st:
diff --git a/pandas/tests/io/test_common.py b/pandas/tests/io/test_common.py
index 26035d1af7f90..718f967f2f3d8 100644
--- a/pandas/tests/io/test_common.py
+++ b/pandas/tests/io/test_common.py
@@ -15,6 +15,7 @@
 import pickle
 import tempfile
 
+import numpy as np
 import pytest
 
 from pandas.compat import is_platform_windows
@@ -442,7 +443,11 @@ def test_next(self, mmap_file):
 
     def test_unknown_engine(self):
         with tm.ensure_clean() as path:
-            df = tm.makeDataFrame()
+            df = pd.DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=pd.Index(list("ABCD"), dtype=object),
+                index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
             df.to_csv(path)
             with pytest.raises(ValueError, match="Unknown engine"):
                 pd.read_csv(path, engine="pyt")
@@ -454,7 +459,11 @@ def test_binary_mode(self):
         GH 35058
         """
         with tm.ensure_clean() as path:
-            df = tm.makeDataFrame()
+            df = pd.DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=pd.Index(list("ABCD"), dtype=object),
+                index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
             df.to_csv(path, mode="w+b")
             tm.assert_frame_equal(df, pd.read_csv(path, index_col=0))
 
@@ -468,7 +477,11 @@ def test_warning_missing_utf_bom(self, encoding, compression_):
 
         GH 35681
         """
-        df = tm.makeDataFrame()
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         with tm.ensure_clean() as path:
             with tm.assert_produces_warning(UnicodeWarning):
                 df.to_csv(path, compression=compression_, encoding=encoding)
@@ -498,7 +511,11 @@ def test_is_fsspec_url():
 @pytest.mark.parametrize("format", ["csv", "json"])
 def test_codecs_encoding(encoding, format):
     # GH39247
-    expected = tm.makeDataFrame()
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     with tm.ensure_clean() as path:
         with codecs.open(path, mode="w", encoding=encoding) as handle:
             getattr(expected, f"to_{format}")(handle)
@@ -512,7 +529,11 @@ def test_codecs_encoding(encoding, format):
 
 def test_codecs_get_writer_reader():
     # GH39247
-    expected = tm.makeDataFrame()
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     with tm.ensure_clean() as path:
         with open(path, "wb") as handle:
             with codecs.getwriter("utf-8")(handle) as encoded:
@@ -534,7 +555,11 @@ def test_explicit_encoding(io_class, mode, msg):
     # GH39247; this test makes sure that if a user provides mode="*t" or "*b",
     # it is used. In the case of this test it leads to an error as intentionally the
     # wrong mode is requested
-    expected = tm.makeDataFrame()
+    expected = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     with io_class() as buffer:
         with pytest.raises(TypeError, match=msg):
             expected.to_csv(buffer, mode=f"w{mode}")
diff --git a/pandas/tests/io/test_compression.py b/pandas/tests/io/test_compression.py
index af83ec4a55fa5..3a58dda9e8dc4 100644
--- a/pandas/tests/io/test_compression.py
+++ b/pandas/tests/io/test_compression.py
@@ -9,6 +9,7 @@
 import time
 import zipfile
 
+import numpy as np
 import pytest
 
 from pandas.compat import is_platform_windows
@@ -142,7 +143,11 @@ def test_compression_binary(compression_only):
 
     GH22555
     """
-    df = tm.makeDataFrame()
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     # with a file
     with tm.ensure_clean() as path:
@@ -170,7 +175,11 @@ def test_gzip_reproducibility_file_name():
 
     GH 28103
     """
-    df = tm.makeDataFrame()
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     compression_options = {"method": "gzip", "mtime": 1}
 
     # test for filename
@@ -189,7 +198,11 @@ def test_gzip_reproducibility_file_object():
 
     GH 28103
     """
-    df = tm.makeDataFrame()
+    df = pd.DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=pd.Index(list("ABCD"), dtype=object),
+        index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     compression_options = {"method": "gzip", "mtime": 1}
 
     # test for file object
diff --git a/pandas/tests/io/test_feather.py b/pandas/tests/io/test_feather.py
index 5ec8705251d95..572abbf7c48f7 100644
--- a/pandas/tests/io/test_feather.py
+++ b/pandas/tests/io/test_feather.py
@@ -132,17 +132,29 @@ def test_rw_use_threads(self):
         self.check_round_trip(df, use_threads=False)
 
     def test_path_pathlib(self):
-        df = tm.makeDataFrame().reset_index()
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
         result = tm.round_trip_pathlib(df.to_feather, read_feather)
         tm.assert_frame_equal(df, result)
 
     def test_path_localpath(self):
-        df = tm.makeDataFrame().reset_index()
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
         result = tm.round_trip_localpath(df.to_feather, read_feather)
         tm.assert_frame_equal(df, result)
 
     def test_passthrough_keywords(self):
-        df = tm.makeDataFrame().reset_index()
+        df = pd.DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        ).reset_index()
         self.check_round_trip(df, write_kwargs={"version": 1})
 
     @pytest.mark.network
diff --git a/pandas/tests/io/test_gcs.py b/pandas/tests/io/test_gcs.py
index 6e55cde12f2f9..0ce6a8bf82cd8 100644
--- a/pandas/tests/io/test_gcs.py
+++ b/pandas/tests/io/test_gcs.py
@@ -9,6 +9,7 @@
 
 from pandas import (
     DataFrame,
+    Index,
     date_range,
     read_csv,
     read_excel,
@@ -145,7 +146,11 @@ def test_to_csv_compression_encoding_gcs(
     GH 35677 (to_csv, compression), GH 26124 (to_csv, encoding), and
     GH 32392 (read_csv, encoding)
     """
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     # reference of compressed and encoded file
     compression = {"method": compression_only}
diff --git a/pandas/tests/io/test_pickle.py b/pandas/tests/io/test_pickle.py
index 780b25fd0f346..e1fac21094139 100644
--- a/pandas/tests/io/test_pickle.py
+++ b/pandas/tests/io/test_pickle.py
@@ -41,6 +41,7 @@
 
 import pandas as pd
 from pandas import (
+    DataFrame,
     Index,
     Series,
     period_range,
@@ -220,13 +221,21 @@ def test_round_trip_current(typ, expected, pickle_writer, writer):
 
 
 def test_pickle_path_pathlib():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     result = tm.round_trip_pathlib(df.to_pickle, pd.read_pickle)
     tm.assert_frame_equal(df, result)
 
 
 def test_pickle_path_localpath():
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
     result = tm.round_trip_localpath(df.to_pickle, pd.read_pickle)
     tm.assert_frame_equal(df, result)
 
@@ -280,7 +289,11 @@ def test_write_explicit(self, compression, get_random_path):
         path2 = base + ".raw"
 
         with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
 
             # write to compressed file
             df.to_pickle(p1, compression=compression)
@@ -299,7 +312,11 @@ def test_write_explicit(self, compression, get_random_path):
     def test_write_explicit_bad(self, compression, get_random_path):
         with pytest.raises(ValueError, match="Unrecognized compression type"):
             with tm.ensure_clean(get_random_path) as path:
-                df = tm.makeDataFrame()
+                df = DataFrame(
+                    1.1 * np.arange(120).reshape((30, 4)),
+                    columns=Index(list("ABCD"), dtype=object),
+                    index=Index([f"i-{i}" for i in range(30)], dtype=object),
+                )
                 df.to_pickle(path, compression=compression)
 
     def test_write_infer(self, compression_ext, get_random_path):
@@ -309,7 +326,11 @@ def test_write_infer(self, compression_ext, get_random_path):
         compression = self._extension_to_compression.get(compression_ext.lower())
 
         with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
 
             # write to compressed file by inferred compression method
             df.to_pickle(p1)
@@ -330,7 +351,11 @@ def test_read_explicit(self, compression, get_random_path):
         path2 = base + ".compressed"
 
         with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
 
             # write to uncompressed file
             df.to_pickle(p1, compression=None)
@@ -349,7 +374,11 @@ def test_read_infer(self, compression_ext, get_random_path):
         compression = self._extension_to_compression.get(compression_ext.lower())
 
         with tm.ensure_clean(path1) as p1, tm.ensure_clean(path2) as p2:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
 
             # write to uncompressed file
             df.to_pickle(p1, compression=None)
@@ -371,7 +400,11 @@ class TestProtocol:
     @pytest.mark.parametrize("protocol", [-1, 0, 1, 2])
     def test_read(self, protocol, get_random_path):
         with tm.ensure_clean(get_random_path) as path:
-            df = tm.makeDataFrame()
+            df = DataFrame(
+                1.1 * np.arange(120).reshape((30, 4)),
+                columns=Index(list("ABCD"), dtype=object),
+                index=Index([f"i-{i}" for i in range(30)], dtype=object),
+            )
             df.to_pickle(path, protocol=protocol)
             df2 = pd.read_pickle(path)
             tm.assert_frame_equal(df, df2)
@@ -404,7 +437,11 @@ def test_unicode_decode_error(datapath, pickle_file, excols):
 
 def test_pickle_buffer_roundtrip():
     with tm.ensure_clean() as path:
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         with open(path, "wb") as fh:
             df.to_pickle(fh)
         with open(path, "rb") as fh:
@@ -450,7 +487,11 @@ def close(self):
         def mock_urlopen_read(*args, **kwargs):
             return MockReadResponse(path)
 
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         python_pickler(df, path)
         monkeypatch.setattr("urllib.request.urlopen", mock_urlopen_read)
         result = pd.read_pickle(mockurl)
@@ -461,7 +502,11 @@ def test_pickle_fsspec_roundtrip():
     pytest.importorskip("fsspec")
     with tm.ensure_clean():
         mockurl = "memory://mockfile"
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.to_pickle(mockurl)
         result = pd.read_pickle(mockurl)
         tm.assert_frame_equal(df, result)
@@ -487,7 +532,11 @@ def test_pickle_binary_object_compression(compression):
 
     GH 26237, GH 29054, and GH 29570
     """
-    df = tm.makeDataFrame()
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
 
     # reference for compression
     with tm.ensure_clean() as path:
@@ -567,7 +616,7 @@ def test_pickle_preserves_block_ndim():
 @pytest.mark.parametrize("protocol", [pickle.DEFAULT_PROTOCOL, pickle.HIGHEST_PROTOCOL])
 def test_pickle_big_dataframe_compression(protocol, compression):
     # GH#39002
-    df = pd.DataFrame(range(100000))
+    df = DataFrame(range(100000))
     result = tm.round_trip_pathlib(
         partial(df.to_pickle, protocol=protocol, compression=compression),
         partial(pd.read_pickle, compression=compression),
@@ -587,13 +636,13 @@ def test_pickle_frame_v124_unpickle_130(datapath):
     with open(path, "rb") as fd:
         df = pickle.load(fd)
 
-    expected = pd.DataFrame(index=[], columns=[])
+    expected = DataFrame(index=[], columns=[])
     tm.assert_frame_equal(df, expected)
 
 
 def test_pickle_pos_args_deprecation():
     # GH-54229
-    df = pd.DataFrame({"a": [1, 2, 3]})
+    df = DataFrame({"a": [1, 2, 3]})
     msg = (
         r"Starting with pandas version 3.0 all arguments of to_pickle except for the "
         r"argument 'path' will be keyword-only."
diff --git a/pandas/tests/io/test_stata.py b/pandas/tests/io/test_stata.py
index 82e6c2964b8c5..19d81d50f5774 100644
--- a/pandas/tests/io/test_stata.py
+++ b/pandas/tests/io/test_stata.py
@@ -1549,14 +1549,22 @@ def test_inf(self, infval):
                 df.to_stata(path)
 
     def test_path_pathlib(self):
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.index.name = "index"
         reader = lambda x: read_stata(x).set_index("index")
         result = tm.round_trip_pathlib(df.to_stata, reader)
         tm.assert_frame_equal(df, result)
 
     def test_pickle_path_localpath(self):
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.index.name = "index"
         reader = lambda x: read_stata(x).set_index("index")
         result = tm.round_trip_localpath(df.to_stata, reader)
@@ -1577,7 +1585,11 @@ def test_value_labels_iterator(self, write_index):
 
     def test_set_index(self):
         # GH 17328
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.index.name = "index"
         with tm.ensure_clean() as path:
             df.to_stata(path)
@@ -1714,7 +1726,11 @@ def test_invalid_date_conversion(self):
     def test_nonfile_writing(self, version):
         # GH 21041
         bio = io.BytesIO()
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.index.name = "index"
         with tm.ensure_clean() as path:
             df.to_stata(bio, version=version)
@@ -1726,7 +1742,11 @@ def test_nonfile_writing(self, version):
 
     def test_gzip_writing(self):
         # writing version 117 requires seek and cannot be used with gzip
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=pd.Index(list("ABCD"), dtype=object),
+            index=pd.Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         df.index.name = "index"
         with tm.ensure_clean() as path:
             with gzip.GzipFile(path, "wb") as gz:
diff --git a/pandas/tests/plotting/test_datetimelike.py b/pandas/tests/plotting/test_datetimelike.py
index bfb9a5a9a1647..3195b7637ee3c 100644
--- a/pandas/tests/plotting/test_datetimelike.py
+++ b/pandas/tests/plotting/test_datetimelike.py
@@ -1314,7 +1314,11 @@ def test_secondary_legend_multi_col(self):
 
     def test_secondary_legend_nonts(self):
         # non-ts
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         fig = mpl.pyplot.figure()
         ax = fig.add_subplot(211)
         ax = df.plot(secondary_y=["A", "B"], ax=ax)
@@ -1331,7 +1335,11 @@ def test_secondary_legend_nonts(self):
 
     def test_secondary_legend_nonts_multi_col(self):
         # non-ts
-        df = tm.makeDataFrame()
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
         fig = mpl.pyplot.figure()
         ax = fig.add_subplot(211)
         ax = df.plot(secondary_y=["C", "D"], ax=ax)
diff --git a/pandas/tests/series/methods/test_reset_index.py b/pandas/tests/series/methods/test_reset_index.py
index 9e6b4ce0df1d6..634b8699a89e6 100644
--- a/pandas/tests/series/methods/test_reset_index.py
+++ b/pandas/tests/series/methods/test_reset_index.py
@@ -33,7 +33,11 @@ def test_reset_index_dti_round_trip(self):
         assert df.reset_index()["Date"].iloc[0] == stamp
 
     def test_reset_index(self):
-        df = tm.makeDataFrame()[:5]
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )[:5]
         ser = df.stack(future_stack=True)
         ser.index.names = ["hash", "category"]