diff --git a/pandas/conftest.py b/pandas/conftest.py
index 003474b57c8e1..7c829ed4b8cb9 100644
--- a/pandas/conftest.py
+++ b/pandas/conftest.py
@@ -1903,7 +1903,7 @@ def using_copy_on_write() -> bool:
 @pytest.fixture
 def warn_copy_on_write() -> bool:
     """
-    Fixture to check if Copy-on-Write is enabled.
+    Fixture to check if Copy-on-Write is in warning mode.
     """
     return (
         pd.options.mode.copy_on_write == "warn"
@@ -1914,9 +1914,9 @@ def warn_copy_on_write() -> bool:
 @pytest.fixture
 def using_infer_string() -> bool:
     """
-    Fixture to check if infer_string is enabled.
+    Fixture to check if infer string option is enabled.
     """
-    return pd.options.future.infer_string
+    return pd.options.future.infer_string is True
 
 
 warsaws = ["Europe/Warsaw", "dateutil/Europe/Warsaw"]
diff --git a/pandas/tests/indexes/base_class/test_formats.py b/pandas/tests/indexes/base_class/test_formats.py
index 379aea8826414..f30b578cfcf56 100644
--- a/pandas/tests/indexes/base_class/test_formats.py
+++ b/pandas/tests/indexes/base_class/test_formats.py
@@ -1,6 +1,7 @@
 import numpy as np
 import pytest
 
+from pandas._config import using_pyarrow_string_dtype
 import pandas._config.config as cf
 
 from pandas import Index
@@ -15,6 +16,7 @@ def test_repr_is_valid_construction_code(self):
         res = eval(repr(idx))
         tm.assert_index_equal(res, idx)
 
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
     @pytest.mark.parametrize(
         "index,expected",
         [
@@ -79,6 +81,7 @@ def test_string_index_repr(self, index, expected):
         result = repr(index)
         assert result == expected
 
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
     @pytest.mark.parametrize(
         "index,expected",
         [
diff --git a/pandas/tests/indexes/base_class/test_reshape.py b/pandas/tests/indexes/base_class/test_reshape.py
index 6586f5f9de480..814a6a516904b 100644
--- a/pandas/tests/indexes/base_class/test_reshape.py
+++ b/pandas/tests/indexes/base_class/test_reshape.py
@@ -33,13 +33,15 @@ def test_insert(self):
 
         # test empty
         null_index = Index([])
-        tm.assert_index_equal(Index(["a"]), null_index.insert(0, "a"))
+        tm.assert_index_equal(Index(["a"], dtype=object), null_index.insert(0, "a"))
 
-    def test_insert_missing(self, nulls_fixture):
+    def test_insert_missing(self, nulls_fixture, using_infer_string):
         # GH#22295
         # test there is no mangling of NA values
-        expected = Index(["a", nulls_fixture, "b", "c"])
-        result = Index(list("abc")).insert(1, nulls_fixture)
+        expected = Index(["a", nulls_fixture, "b", "c"], dtype=object)
+        result = Index(list("abc"), dtype=object).insert(
+            1, Index([nulls_fixture], dtype=object)
+        )
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/indexes/base_class/test_setops.py b/pandas/tests/indexes/base_class/test_setops.py
index e538ad512d691..3ef3f3ad4d3a2 100644
--- a/pandas/tests/indexes/base_class/test_setops.py
+++ b/pandas/tests/indexes/base_class/test_setops.py
@@ -154,7 +154,7 @@ def test_intersection_str_dates(self, sort):
     def test_intersection_non_monotonic_non_unique(self, index2, expected_arr, sort):
         # non-monotonic non-unique
         index1 = Index(["A", "B", "A", "C"])
-        expected = Index(expected_arr, dtype="object")
+        expected = Index(expected_arr)
         result = index1.intersection(index2, sort=sort)
         if sort is None:
             expected = expected.sort_values()
diff --git a/pandas/tests/indexes/categorical/test_astype.py b/pandas/tests/indexes/categorical/test_astype.py
index da1d692f9eb2d..a17627b7515b2 100644
--- a/pandas/tests/indexes/categorical/test_astype.py
+++ b/pandas/tests/indexes/categorical/test_astype.py
@@ -18,7 +18,7 @@ def test_astype(self):
         ci = CategoricalIndex(list("aabbca"), categories=list("cab"), ordered=False)
 
         result = ci.astype(object)
-        tm.assert_index_equal(result, Index(np.array(ci)))
+        tm.assert_index_equal(result, Index(np.array(ci), dtype=object))
 
         # this IS equal, but not the same class
         assert result.equals(ci)
diff --git a/pandas/tests/indexes/categorical/test_category.py b/pandas/tests/indexes/categorical/test_category.py
index 142a00d32815a..03a298a13dc2b 100644
--- a/pandas/tests/indexes/categorical/test_category.py
+++ b/pandas/tests/indexes/categorical/test_category.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas._config import using_pyarrow_string_dtype
+
 from pandas._libs import index as libindex
 from pandas._libs.arrays import NDArrayBacked
 
@@ -47,7 +49,7 @@ def test_insert(self, simple_index):
 
         # invalid -> cast to object
         expected = ci.astype(object).insert(0, "d")
-        result = ci.insert(0, "d")
+        result = ci.insert(0, "d").astype(object)
         tm.assert_index_equal(result, expected, exact=True)
 
         # GH 18295 (test missing)
@@ -194,6 +196,7 @@ def test_unique(self, data, categories, expected_data, ordered):
         expected = CategoricalIndex(expected_data, dtype=dtype)
         tm.assert_index_equal(idx.unique(), expected)
 
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr doesn't roundtrip")
     def test_repr_roundtrip(self):
         ci = CategoricalIndex(["a", "b"], categories=["a", "b"], ordered=True)
         str(ci)
diff --git a/pandas/tests/indexes/categorical/test_formats.py b/pandas/tests/indexes/categorical/test_formats.py
index ea3e4ce213e67..522ca1bc2afde 100644
--- a/pandas/tests/indexes/categorical/test_formats.py
+++ b/pandas/tests/indexes/categorical/test_formats.py
@@ -1,6 +1,9 @@
 """
 Tests for CategoricalIndex.__repr__ and related methods.
 """
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
 import pandas._config.config as cf
 
 from pandas import CategoricalIndex
@@ -16,6 +19,7 @@ def test_format_different_scalar_lengths(self):
         with tm.assert_produces_warning(FutureWarning, match=msg):
             assert idx.format() == expected
 
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
     def test_string_categorical_index_repr(self):
         # short
         idx = CategoricalIndex(["a", "bb", "ccc"])
diff --git a/pandas/tests/indexes/categorical/test_reindex.py b/pandas/tests/indexes/categorical/test_reindex.py
index 8ca5c6099b4e7..5b1f2b9fb159a 100644
--- a/pandas/tests/indexes/categorical/test_reindex.py
+++ b/pandas/tests/indexes/categorical/test_reindex.py
@@ -40,7 +40,7 @@ def test_reindex_duplicate_target(self):
         # See GH25459
         cat = CategoricalIndex(["a", "b", "c"], categories=["a", "b", "c", "d"])
         res, indexer = cat.reindex(["a", "c", "c"])
-        exp = Index(["a", "c", "c"], dtype="object")
+        exp = Index(["a", "c", "c"])
         tm.assert_index_equal(res, exp, exact=True)
         tm.assert_numpy_array_equal(indexer, np.array([0, 2, 2], dtype=np.intp))
 
diff --git a/pandas/tests/indexes/datetimes/methods/test_map.py b/pandas/tests/indexes/datetimes/methods/test_map.py
index c31e2407190ea..f35f07bd32068 100644
--- a/pandas/tests/indexes/datetimes/methods/test_map.py
+++ b/pandas/tests/indexes/datetimes/methods/test_map.py
@@ -16,7 +16,7 @@ def test_map(self):
 
         f = lambda x: x.strftime("%Y%m%d")
         result = rng.map(f)
-        exp = Index([f(x) for x in rng], dtype="<U8")
+        exp = Index([f(x) for x in rng])
         tm.assert_index_equal(result, exp)
 
     def test_map_fallthrough(self, capsys):
diff --git a/pandas/tests/indexes/interval/test_formats.py b/pandas/tests/indexes/interval/test_formats.py
index edd7993056512..3b8e18463160f 100644
--- a/pandas/tests/indexes/interval/test_formats.py
+++ b/pandas/tests/indexes/interval/test_formats.py
@@ -1,6 +1,8 @@
 import numpy as np
 import pytest
 
+from pandas._config import using_pyarrow_string_dtype
+
 from pandas import (
     DataFrame,
     DatetimeIndex,
@@ -31,13 +33,16 @@ class TestIntervalIndexRendering:
             (DataFrame, ("            0\n(0.0, 1.0]  a\nNaN         b\n(2.0, 3.0]  c")),
         ],
     )
-    def test_repr_missing(self, constructor, expected):
+    def test_repr_missing(self, constructor, expected, using_infer_string, request):
         # GH 25984
+        if using_infer_string and constructor is Series:
+            request.applymarker(pytest.mark.xfail(reason="repr different"))
         index = IntervalIndex.from_tuples([(0, 1), np.nan, (2, 3)])
         obj = constructor(list("abc"), index=index)
         result = repr(obj)
         assert result == expected
 
+    @pytest.mark.xfail(using_pyarrow_string_dtype(), reason="repr different")
     def test_repr_floats(self):
         # GH 32553
 
diff --git a/pandas/tests/indexes/multi/test_constructors.py b/pandas/tests/indexes/multi/test_constructors.py
index 32659bc2f7bff..8456e6a7acba5 100644
--- a/pandas/tests/indexes/multi/test_constructors.py
+++ b/pandas/tests/indexes/multi/test_constructors.py
@@ -847,11 +847,14 @@ def test_multiindex_inference_consistency():
     assert lev.dtype == object
 
 
-def test_dtype_representation():
+def test_dtype_representation(using_infer_string):
     # GH#46900
     pmidx = MultiIndex.from_arrays([[1], ["a"]], names=[("a", "b"), ("c", "d")])
     result = pmidx.dtypes
+    exp = "object" if not using_infer_string else "string"
     expected = Series(
-        ["int64", "object"], index=MultiIndex.from_tuples([("a", "b"), ("c", "d")])
+        ["int64", exp],
+        index=MultiIndex.from_tuples([("a", "b"), ("c", "d")]),
+        dtype=object,
     )
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_get_set.py b/pandas/tests/indexes/multi/test_get_set.py
index e362fc8a05a46..6eeaeb6711d03 100644
--- a/pandas/tests/indexes/multi/test_get_set.py
+++ b/pandas/tests/indexes/multi/test_get_set.py
@@ -34,23 +34,25 @@ def test_get_level_number_integer(idx):
         idx._get_level_number("fourth")
 
 
-def test_get_dtypes():
+def test_get_dtypes(using_infer_string):
     # Test MultiIndex.dtypes (# Gh37062)
     idx_multitype = MultiIndex.from_product(
         [[1, 2, 3], ["a", "b", "c"], pd.date_range("20200101", periods=2, tz="UTC")],
         names=["int", "string", "dt"],
     )
+
+    exp = "object" if not using_infer_string else "string"
     expected = pd.Series(
         {
             "int": np.dtype("int64"),
-            "string": np.dtype("O"),
+            "string": exp,
             "dt": DatetimeTZDtype(tz="utc"),
         }
     )
     tm.assert_series_equal(expected, idx_multitype.dtypes)
 
 
-def test_get_dtypes_no_level_name():
+def test_get_dtypes_no_level_name(using_infer_string):
     # Test MultiIndex.dtypes (# GH38580 )
     idx_multitype = MultiIndex.from_product(
         [
@@ -59,17 +61,18 @@ def test_get_dtypes_no_level_name():
             pd.date_range("20200101", periods=2, tz="UTC"),
         ],
     )
+    exp = "object" if not using_infer_string else "string"
     expected = pd.Series(
         {
             "level_0": np.dtype("int64"),
-            "level_1": np.dtype("O"),
+            "level_1": exp,
             "level_2": DatetimeTZDtype(tz="utc"),
         }
     )
     tm.assert_series_equal(expected, idx_multitype.dtypes)
 
 
-def test_get_dtypes_duplicate_level_names():
+def test_get_dtypes_duplicate_level_names(using_infer_string):
     # Test MultiIndex.dtypes with non-unique level names (# GH45174)
     result = MultiIndex.from_product(
         [
@@ -79,8 +82,9 @@ def test_get_dtypes_duplicate_level_names():
         ],
         names=["A", "A", "A"],
     ).dtypes
+    exp = "object" if not using_infer_string else "string"
     expected = pd.Series(
-        [np.dtype("int64"), np.dtype("O"), DatetimeTZDtype(tz="utc")],
+        [np.dtype("int64"), exp, DatetimeTZDtype(tz="utc")],
         index=["A", "A", "A"],
     )
     tm.assert_series_equal(result, expected)
diff --git a/pandas/tests/indexes/multi/test_reindex.py b/pandas/tests/indexes/multi/test_reindex.py
index 77a527134b79f..d1b4fe8b98760 100644
--- a/pandas/tests/indexes/multi/test_reindex.py
+++ b/pandas/tests/indexes/multi/test_reindex.py
@@ -75,11 +75,14 @@ def test_reindex_lvl_preserves_names_when_target_is_list_or_array():
     assert idx.reindex([], level=1)[0].names == ["foo", "bar"]
 
 
-def test_reindex_lvl_preserves_type_if_target_is_empty_list_or_array():
+def test_reindex_lvl_preserves_type_if_target_is_empty_list_or_array(
+    using_infer_string,
+):
     # GH7774
     idx = MultiIndex.from_product([[0, 1], ["a", "b"]])
     assert idx.reindex([], level=0)[0].levels[0].dtype.type == np.int64
-    assert idx.reindex([], level=1)[0].levels[1].dtype.type == np.object_
+    exp = np.object_ if not using_infer_string else str
+    assert idx.reindex([], level=1)[0].levels[1].dtype.type == exp
 
     # case with EA levels
     cat = pd.Categorical(["foo", "bar"])
diff --git a/pandas/tests/indexes/multi/test_setops.py b/pandas/tests/indexes/multi/test_setops.py
index be266f5d8fdce..0abb56ecf9de7 100644
--- a/pandas/tests/indexes/multi/test_setops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -263,19 +263,23 @@ def test_union(idx, sort):
         assert result.equals(idx)
 
 
-def test_union_with_regular_index(idx):
+def test_union_with_regular_index(idx, using_infer_string):
     other = Index(["A", "B", "C"])
 
     result = other.union(idx)
     assert ("foo", "one") in result
     assert "B" in result
 
-    msg = "The values in the array are unorderable"
-    with tm.assert_produces_warning(RuntimeWarning, match=msg):
-        result2 = idx.union(other)
-    # This is more consistent now, if sorting fails then we don't sort at all
-    # in the MultiIndex case.
-    assert not result.equals(result2)
+    if using_infer_string:
+        with pytest.raises(NotImplementedError, match="Can only union"):
+            idx.union(other)
+    else:
+        msg = "The values in the array are unorderable"
+        with tm.assert_produces_warning(RuntimeWarning, match=msg):
+            result2 = idx.union(other)
+        # This is more consistent now, if sorting fails then we don't sort at all
+        # in the MultiIndex case.
+        assert not result.equals(result2)
 
 
 def test_intersection(idx, sort):
@@ -756,7 +760,12 @@ def test_intersection_keep_ea_dtypes(val, any_numeric_ea_dtype):
 
 def test_union_with_na_when_constructing_dataframe():
     # GH43222
-    series1 = Series((1,), index=MultiIndex.from_tuples(((None, None),)))
+    series1 = Series(
+        (1,),
+        index=MultiIndex.from_arrays(
+            [Series([None], dtype="string"), Series([None], dtype="string")]
+        ),
+    )
     series2 = Series((10, 20), index=MultiIndex.from_tuples(((None, None), ("a", "b"))))
     result = DataFrame([series1, series2])
     expected = DataFrame({(np.nan, np.nan): [1.0, 10.0], ("a", "b"): [np.nan, 20.0]})
diff --git a/pandas/tests/indexes/object/test_astype.py b/pandas/tests/indexes/object/test_astype.py
index 273b39b5e319d..9c1ef302c5b51 100644
--- a/pandas/tests/indexes/object/test_astype.py
+++ b/pandas/tests/indexes/object/test_astype.py
@@ -20,7 +20,7 @@ def test_astype_str_from_bytes():
 
     # while we're here, check that Series.astype behaves the same
     result = Series(idx).astype(str)
-    expected = Series(expected)
+    expected = Series(expected, dtype=object)
     tm.assert_series_equal(result, expected)
 
 
diff --git a/pandas/tests/indexes/object/test_indexing.py b/pandas/tests/indexes/object/test_indexing.py
index 93d46ebdd0b51..ebf9dac715f8d 100644
--- a/pandas/tests/indexes/object/test_indexing.py
+++ b/pandas/tests/indexes/object/test_indexing.py
@@ -3,7 +3,10 @@
 import numpy as np
 import pytest
 
-from pandas._libs.missing import is_matching_na
+from pandas._libs.missing import (
+    NA,
+    is_matching_na,
+)
 import pandas.util._test_decorators as td
 
 import pandas as pd
@@ -25,20 +28,36 @@ def test_get_indexer_strings(self, method, expected):
 
         tm.assert_numpy_array_equal(actual, expected)
 
-    def test_get_indexer_strings_raises(self):
+    def test_get_indexer_strings_raises(self, using_infer_string):
         index = Index(["b", "c"])
 
-        msg = r"unsupported operand type\(s\) for -: 'str' and 'str'"
-        with pytest.raises(TypeError, match=msg):
-            index.get_indexer(["a", "b", "c", "d"], method="nearest")
+        if using_infer_string:
+            import pyarrow as pa
 
-        with pytest.raises(TypeError, match=msg):
-            index.get_indexer(["a", "b", "c", "d"], method="pad", tolerance=2)
+            msg = "has no kernel"
+            with pytest.raises(pa.lib.ArrowNotImplementedError, match=msg):
+                index.get_indexer(["a", "b", "c", "d"], method="nearest")
 
-        with pytest.raises(TypeError, match=msg):
-            index.get_indexer(
-                ["a", "b", "c", "d"], method="pad", tolerance=[2, 2, 2, 2]
-            )
+            with pytest.raises(pa.lib.ArrowNotImplementedError, match=msg):
+                index.get_indexer(["a", "b", "c", "d"], method="pad", tolerance=2)
+
+            with pytest.raises(pa.lib.ArrowNotImplementedError, match=msg):
+                index.get_indexer(
+                    ["a", "b", "c", "d"], method="pad", tolerance=[2, 2, 2, 2]
+                )
+
+        else:
+            msg = r"unsupported operand type\(s\) for -: 'str' and 'str'"
+            with pytest.raises(TypeError, match=msg):
+                index.get_indexer(["a", "b", "c", "d"], method="nearest")
+
+            with pytest.raises(TypeError, match=msg):
+                index.get_indexer(["a", "b", "c", "d"], method="pad", tolerance=2)
+
+            with pytest.raises(TypeError, match=msg):
+                index.get_indexer(
+                    ["a", "b", "c", "d"], method="pad", tolerance=[2, 2, 2, 2]
+                )
 
     def test_get_indexer_with_NA_values(
         self, unique_nulls_fixture, unique_nulls_fixture2
@@ -51,15 +70,21 @@ def test_get_indexer_with_NA_values(
         arr = np.array([unique_nulls_fixture, unique_nulls_fixture2], dtype=object)
         index = Index(arr, dtype=object)
         result = index.get_indexer(
-            [unique_nulls_fixture, unique_nulls_fixture2, "Unknown"]
+            Index(
+                [unique_nulls_fixture, unique_nulls_fixture2, "Unknown"], dtype=object
+            )
         )
         expected = np.array([0, 1, -1], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
 
 class TestGetIndexerNonUnique:
-    def test_get_indexer_non_unique_nas(self, nulls_fixture):
+    def test_get_indexer_non_unique_nas(
+        self, nulls_fixture, request, using_infer_string
+    ):
         # even though this isn't non-unique, this should still work
+        if using_infer_string and (nulls_fixture is None or nulls_fixture is NA):
+            request.applymarker(pytest.mark.xfail(reason="NAs are cast to NaN"))
         index = Index(["a", "b", nulls_fixture])
         indexer, missing = index.get_indexer_non_unique([nulls_fixture])
 
diff --git a/pandas/tests/indexes/period/methods/test_astype.py b/pandas/tests/indexes/period/methods/test_astype.py
index ba60ffd1fff4d..d545bfd2fae0f 100644
--- a/pandas/tests/indexes/period/methods/test_astype.py
+++ b/pandas/tests/indexes/period/methods/test_astype.py
@@ -41,7 +41,7 @@ def test_astype_conversion(self):
         tm.assert_index_equal(result, expected)
 
         result = idx.astype(str)
-        expected = Index([str(x) for x in idx], name="idx")
+        expected = Index([str(x) for x in idx], name="idx", dtype=object)
         tm.assert_index_equal(result, expected)
 
         idx = period_range("1990", "2009", freq="Y", name="idx")
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index bb8822f047330..bc8aa28c21d33 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -72,12 +72,17 @@ def test_constructor_casting(self, index):
         tm.assert_index_equal(index, new_index)
 
     @pytest.mark.parametrize("index", ["string"], indirect=True)
-    def test_constructor_copy(self, index):
+    def test_constructor_copy(self, index, using_infer_string):
         arr = np.array(index)
         new_index = Index(arr, copy=True, name="name")
         assert isinstance(new_index, Index)
         assert new_index.name == "name"
-        tm.assert_numpy_array_equal(arr, new_index.values)
+        if using_infer_string:
+            tm.assert_extension_array_equal(
+                new_index.values, pd.array(arr, dtype="string[pyarrow_numpy]")
+            )
+        else:
+            tm.assert_numpy_array_equal(arr, new_index.values)
         arr[0] = "SOMEBIGLONGSTRING"
         assert new_index[0] != "SOMEBIGLONGSTRING"
 
@@ -145,7 +150,7 @@ def test_constructor_from_series_freq(self):
 
         tm.assert_index_equal(result, expected)
 
-    def test_constructor_from_frame_series_freq(self):
+    def test_constructor_from_frame_series_freq(self, using_infer_string):
         # GH 6273
         # create from a series, passing a freq
         dts = ["1-1-1990", "2-1-1990", "3-1-1990", "4-1-1990", "5-1-1990"]
@@ -154,8 +159,8 @@ def test_constructor_from_frame_series_freq(self):
         df = DataFrame(np.random.default_rng(2).random((5, 3)))
         df["date"] = dts
         result = DatetimeIndex(df["date"], freq="MS")
-
-        assert df["date"].dtype == object
+        dtype = object if not using_infer_string else "string"
+        assert df["date"].dtype == dtype
         expected.name = "date"
         tm.assert_index_equal(result, expected)
 
@@ -164,8 +169,10 @@ def test_constructor_from_frame_series_freq(self):
 
         # GH 6274
         # infer freq of same
-        freq = pd.infer_freq(df["date"])
-        assert freq == "MS"
+        if not using_infer_string:
+            # Doesn't work with arrow strings
+            freq = pd.infer_freq(df["date"])
+            assert freq == "MS"
 
     def test_constructor_int_dtype_nan(self):
         # see gh-15187
@@ -346,6 +353,9 @@ def test_view_with_args_object_array_raises(self, index):
             msg = "When changing to a larger dtype"
             with pytest.raises(ValueError, match=msg):
                 index.view("i8")
+        elif index.dtype == "string":
+            with pytest.raises(NotImplementedError, match="i8"):
+                index.view("i8")
         else:
             msg = "Cannot change data-type for object array"
             with pytest.raises(TypeError, match=msg):
@@ -459,7 +469,9 @@ def test_fancy(self, simple_index):
         indirect=True,
     )
     @pytest.mark.parametrize("dtype", [int, np.bool_])
-    def test_empty_fancy(self, index, dtype):
+    def test_empty_fancy(self, index, dtype, request, using_infer_string):
+        if dtype is np.bool_ and using_infer_string and index.dtype == "string":
+            request.applymarker(pytest.mark.xfail(reason="numpy behavior is buggy"))
         empty_arr = np.array([], dtype=dtype)
         empty_index = type(index)([], dtype=index.dtype)
 
@@ -483,7 +495,7 @@ def test_empty_fancy_raises(self, index):
 
         assert index[[]].identical(empty_index)
         # np.ndarray only accepts ndarray of int & bool dtypes, so should Index
-        msg = r"arrays used as indices must be of integer \(or boolean\) type"
+        msg = r"arrays used as indices must be of integer"
         with pytest.raises(IndexError, match=msg):
             index[empty_farr]
 
@@ -665,7 +677,9 @@ def test_is_numeric(self, index, expected):
         ],
         indirect=["index"],
     )
-    def test_is_object(self, index, expected):
+    def test_is_object(self, index, expected, using_infer_string):
+        if using_infer_string and index.dtype == "string" and expected:
+            expected = False
         assert is_object_dtype(index) is expected
 
     def test_summary(self, index):
@@ -785,7 +799,7 @@ def test_drop_by_numeric_label_errors_ignore(self, key, expected):
     def test_drop_tuple(self, values, to_drop):
         # GH 18304
         index = Index(values)
-        expected = Index(["b"])
+        expected = Index(["b"], dtype=object)
 
         result = index.drop(to_drop)
         tm.assert_index_equal(result, expected)
@@ -838,9 +852,12 @@ def test_isin(self, values, index, expected):
         result = index.isin(values)
         tm.assert_numpy_array_equal(result, expected)
 
-    def test_isin_nan_common_object(self, nulls_fixture, nulls_fixture2):
+    def test_isin_nan_common_object(
+        self, nulls_fixture, nulls_fixture2, using_infer_string
+    ):
         # Test cartesian product of null fixtures and ensure that we don't
         # mangle the various types (save a corner case with PyPy)
+        idx = Index(["a", nulls_fixture])
 
         # all nans are the same
         if (
@@ -850,19 +867,25 @@ def test_isin_nan_common_object(self, nulls_fixture, nulls_fixture2):
             and math.isnan(nulls_fixture2)
         ):
             tm.assert_numpy_array_equal(
-                Index(["a", nulls_fixture]).isin([nulls_fixture2]),
+                idx.isin([nulls_fixture2]),
                 np.array([False, True]),
             )
 
         elif nulls_fixture is nulls_fixture2:  # should preserve NA type
             tm.assert_numpy_array_equal(
-                Index(["a", nulls_fixture]).isin([nulls_fixture2]),
+                idx.isin([nulls_fixture2]),
+                np.array([False, True]),
+            )
+
+        elif using_infer_string and idx.dtype == "string":
+            tm.assert_numpy_array_equal(
+                idx.isin([nulls_fixture2]),
                 np.array([False, True]),
             )
 
         else:
             tm.assert_numpy_array_equal(
-                Index(["a", nulls_fixture]).isin([nulls_fixture2]),
+                idx.isin([nulls_fixture2]),
                 np.array([False, False]),
             )
 
@@ -1138,7 +1161,7 @@ def test_reindex_preserves_name_if_target_is_list_or_ndarray(self, name, labels)
     def test_reindex_preserves_type_if_target_is_empty_list_or_array(self, labels):
         # GH7774
         index = Index(list("abc"))
-        assert index.reindex(labels)[0].dtype.type == np.object_
+        assert index.reindex(labels)[0].dtype.type == index.dtype.type
 
     @pytest.mark.parametrize(
         "labels,dtype",
@@ -1230,7 +1253,7 @@ def test_equals_op_mismatched_multiindex_raises(self, index):
         with pytest.raises(ValueError, match="Lengths must match"):
             df.index == index
 
-    def test_equals_op_index_vs_mi_same_length(self):
+    def test_equals_op_index_vs_mi_same_length(self, using_infer_string):
         mi = MultiIndex.from_tuples([(1, 2), (4, 5), (8, 9)])
         index = Index(["foo", "bar", "baz"])
 
diff --git a/pandas/tests/indexes/test_old_base.py b/pandas/tests/indexes/test_old_base.py
index f08de8e65451c..528ef2e19aaec 100644
--- a/pandas/tests/indexes/test_old_base.py
+++ b/pandas/tests/indexes/test_old_base.py
@@ -6,6 +6,8 @@
 import numpy as np
 import pytest
 
+from pandas._config import using_pyarrow_string_dtype
+
 from pandas._libs.tslibs import Timestamp
 
 from pandas.core.dtypes.common import (
@@ -209,7 +211,7 @@ def test_numeric_compat(self, simple_index):
             1 // idx
 
     def test_logical_compat(self, simple_index):
-        if simple_index.dtype == object:
+        if simple_index.dtype in (object, "string"):
             pytest.skip("Tested elsewhere.")
         idx = simple_index
         if idx.dtype.kind in "iufcbm":
@@ -297,7 +299,7 @@ def test_ensure_copied_data(self, index):
                 tm.assert_numpy_array_equal(
                     index._values._ndarray, result._values._ndarray, check_same="same"
                 )
-            elif index.dtype == "string[pyarrow]":
+            elif index.dtype in ("string[pyarrow]", "string[pyarrow_numpy]"):
                 assert tm.shares_memory(result._values, index._values)
             else:
                 raise NotImplementedError(index.dtype)
@@ -415,6 +417,10 @@ def test_insert_base(self, index):
         # test 0th element
         assert index[0:4].equals(result.insert(0, index[0]))
 
+    @pytest.mark.skipif(
+        using_pyarrow_string_dtype(),
+        reason="completely different behavior, tested elsewher",
+    )
     def test_insert_out_of_bounds(self, index):
         # TypeError/IndexError matches what np.insert raises in these cases
 
@@ -692,7 +698,7 @@ def test_map_str(self, simple_index):
             pytest.skip("See test_map.py")
         idx = simple_index
         result = idx.map(str)
-        expected = Index([str(x) for x in idx], dtype=object)
+        expected = Index([str(x) for x in idx])
         tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize("copy", [True, False])
@@ -757,15 +763,15 @@ def test_getitem_2d_deprecated(self, simple_index):
         if isinstance(simple_index, IntervalIndex):
             pytest.skip("Tested elsewhere")
         idx = simple_index
-        msg = "Multi-dimensional indexing"
-        with pytest.raises(ValueError, match=msg):
+        msg = "Multi-dimensional indexing|too many|only"
+        with pytest.raises((ValueError, IndexError), match=msg):
             idx[:, None]
 
         if not isinstance(idx, RangeIndex):
             # GH#44051 RangeIndex already raised pre-2.0 with a different message
-            with pytest.raises(ValueError, match=msg):
+            with pytest.raises((ValueError, IndexError), match=msg):
                 idx[True]
-            with pytest.raises(ValueError, match=msg):
+            with pytest.raises((ValueError, IndexError), match=msg):
                 idx[False]
         else:
             msg = "only integers, slices"
@@ -829,7 +835,7 @@ def test_append_preserves_dtype(self, simple_index):
         alt = index.take(list(range(N)) * 2)
         tm.assert_index_equal(result, alt, check_exact=True)
 
-    def test_inv(self, simple_index):
+    def test_inv(self, simple_index, using_infer_string):
         idx = simple_index
 
         if idx.dtype.kind in ["i", "u"]:
@@ -842,14 +848,21 @@ def test_inv(self, simple_index):
             tm.assert_series_equal(res2, Series(expected))
         else:
             if idx.dtype.kind == "f":
+                err = TypeError
                 msg = "ufunc 'invert' not supported for the input types"
+            elif using_infer_string and idx.dtype == "string":
+                import pyarrow as pa
+
+                err = pa.lib.ArrowNotImplementedError
+                msg = "has no kernel"
             else:
+                err = TypeError
                 msg = "bad operand"
-            with pytest.raises(TypeError, match=msg):
+            with pytest.raises(err, match=msg):
                 ~idx
 
             # check that we get the same behavior with Series
-            with pytest.raises(TypeError, match=msg):
+            with pytest.raises(err, match=msg):
                 ~Series(idx)
 
     def test_is_boolean_is_deprecated(self, simple_index):
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index a489c51a808fd..4a6982cf98670 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -802,10 +802,10 @@ def test_union_identity(self, index, sort):
 
         # This should no longer be the same object, since [] is not consistent,
         # both objects will be recast to dtype('O')
-        union = first.union([], sort=sort)
+        union = first.union(Index([], dtype=first.dtype), sort=sort)
         assert (union is first) is (not sort)
 
-        union = Index([]).union(first, sort=sort)
+        union = Index([], dtype=first.dtype).union(first, sort=sort)
         assert (union is first) is (not sort)
 
     @pytest.mark.parametrize("index", ["string"], indirect=True)
diff --git a/pandas/tests/indexes/timedeltas/methods/test_astype.py b/pandas/tests/indexes/timedeltas/methods/test_astype.py
index 6aeb1fc23dae9..311f2b5c9aa59 100644
--- a/pandas/tests/indexes/timedeltas/methods/test_astype.py
+++ b/pandas/tests/indexes/timedeltas/methods/test_astype.py
@@ -61,7 +61,7 @@ def test_astype(self):
         tm.assert_index_equal(result, expected)
 
         result = idx.astype(str)
-        expected = Index([str(x) for x in idx], name="idx")
+        expected = Index([str(x) for x in idx], name="idx", dtype=object)
         tm.assert_index_equal(result, expected)
 
         rng = timedelta_range("1 days", periods=10)