snowpark-connect 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/indexes/test_base.py

@@ -1,2743 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import inspect
-import unittest
-from distutils.version import LooseVersion
-from datetime import datetime, timedelta
-
-import numpy as np
-import pandas as pd
-
-import pyspark.pandas as ps
-from pyspark.pandas.exceptions import PandasNotImplementedError
-from pyspark.pandas.missing.indexes import (
-    MissingPandasLikeDatetimeIndex,
-    MissingPandasLikeIndex,
-    MissingPandasLikeMultiIndex,
-    MissingPandasLikeTimedeltaIndex,
-)
-from pyspark.testing.pandasutils import ComparisonTestBase, TestUtils, SPARK_CONF_ARROW_ENABLED
-
-
-class IndexesTestsMixin:
-    @property
-    def pdf(self):
-        return pd.DataFrame(
-            {"a": [1, 2, 3, 4, 5, 6, 7, 8, 9], "b": [4, 5, 6, 3, 2, 1, 0, 0, 0]},
-            index=[0, 1, 3, 5, 6, 8, 9, 9, 9],
-        )
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43606): Enable IndexesTests.test_index_basic for pandas 2.0.0.",
-    )
-    def test_index_basic(self):
-        for pdf in [
-            pd.DataFrame(np.random.randn(10, 5), index=np.random.randint(100, size=10)),
-            pd.DataFrame(
-                np.random.randn(10, 5), index=np.random.randint(100, size=10).astype(np.int32)
-            ),
-            pd.DataFrame(np.random.randn(10, 5), index=np.random.randn(10)),
-            pd.DataFrame(np.random.randn(10, 5), index=np.random.randn(10).astype(np.float32)),
-            pd.DataFrame(np.random.randn(10, 5), index=list("abcdefghij")),
-            pd.DataFrame(
-                np.random.randn(10, 5), index=pd.date_range("2011-01-01", freq="D", periods=10)
-            ),
-            pd.DataFrame(np.random.randn(10, 5), index=pd.Categorical(list("abcdefghij"))),
-            pd.DataFrame(np.random.randn(10, 5), columns=list("abcde")).set_index(["a", "b"]),
-        ]:
-            psdf = ps.from_pandas(pdf)
-            self.assert_eq(psdf.index, pdf.index)
-            # Int64Index is removed from pandas 2.0.0, so we should compare the dtype itself.
-            if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-                self.assert_eq(psdf.index.dtype, pdf.index.dtype)
-            else:
-                self.assert_eq(type(psdf.index).__name__, type(pdf.index).__name__)
-
-        self.assert_eq(ps.Index([])._summary(), "Index: 0 entries")
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            with self.assertRaisesRegexp(ValueError, "The truth value of a Index is ambiguous."):
-                bool(ps.Index([1]))
-            with self.assertRaisesRegexp(TypeError, "Index.name must be a hashable type"):
-                ps.Index([1, 2, 3], name=[(1, 2, 3)])
-            with self.assertRaisesRegexp(TypeError, "Index.name must be a hashable type"):
-                ps.Index([1.0, 2.0, 3.0], name=[(1, 2, 3)])
-        else:
-            with self.assertRaisesRegexp(
-                ValueError, "The truth value of a Int64Index is ambiguous."
-            ):
-                bool(ps.Index([1]))
-            with self.assertRaisesRegexp(TypeError, "Index.name must be a hashable type"):
-                ps.Int64Index([1, 2, 3], name=[(1, 2, 3)])
-            with self.assertRaisesRegexp(TypeError, "Index.name must be a hashable type"):
-                ps.Float64Index([1.0, 2.0, 3.0], name=[(1, 2, 3)])
-
-    def test_index_from_series(self):
-        pser = pd.Series([1, 2, 3], name="a", index=[10, 20, 30])
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(ps.Index(psser), pd.Index(pser))
-        self.assert_eq(ps.Index(psser, dtype="float"), pd.Index(pser, dtype="float"))
-        self.assert_eq(ps.Index(psser, name="x"), pd.Index(pser, name="x"))
-
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(ps.Index(psser, dtype="int64"), pd.Index(pser, dtype="int64"))
-            self.assert_eq(ps.Index(psser, dtype="float64"), pd.Index(pser, dtype="float64"))
-        elif LooseVersion(pd.__version__) >= LooseVersion("1.1"):
-            self.assert_eq(ps.Int64Index(psser), pd.Int64Index(pser))
-            self.assert_eq(ps.Float64Index(psser), pd.Float64Index(pser))
-        else:
-            self.assert_eq(ps.Int64Index(psser), pd.Int64Index(pser).rename("a"))
-            self.assert_eq(ps.Float64Index(psser), pd.Float64Index(pser).rename("a"))
-
-        pser = pd.Series([datetime(2021, 3, 1), datetime(2021, 3, 2)], name="x", index=[10, 20])
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(ps.Index(psser), pd.Index(pser))
-        self.assert_eq(ps.DatetimeIndex(psser), pd.DatetimeIndex(pser))
-
-    def test_index_from_index(self):
-        pidx = pd.Index([1, 2, 3], name="a")
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(ps.Index(psidx), pd.Index(pidx))
-        self.assert_eq(ps.Index(psidx, dtype="float"), pd.Index(pidx, dtype="float"))
-        self.assert_eq(ps.Index(psidx, name="x"), pd.Index(pidx, name="x"))
-        self.assert_eq(ps.Index(psidx, copy=True), pd.Index(pidx, copy=True))
-
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(ps.Index(psidx, dtype="int64"), pd.Index(pidx, dtype="int64"))
-            self.assert_eq(ps.Index(psidx, dtype="float64"), pd.Index(pidx, dtype="float64"))
-        else:
-            self.assert_eq(ps.Int64Index(psidx), pd.Int64Index(pidx))
-            self.assert_eq(ps.Float64Index(psidx), pd.Float64Index(pidx))
-
-        pidx = pd.DatetimeIndex(["2021-03-01", "2021-03-02"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(ps.Index(psidx), pd.Index(pidx))
-        self.assert_eq(ps.DatetimeIndex(psidx), pd.DatetimeIndex(pidx))
-
-    def test_index_getattr(self):
-        psidx = self.psdf.index
-        item = "databricks"
-
-        expected_error_message = "'.*Index' object has no attribute '{}'".format(item)
-        with self.assertRaisesRegex(AttributeError, expected_error_message):
-            psidx.__getattr__(item)
-        with self.assertRaisesRegex(AttributeError, expected_error_message):
-            ps.from_pandas(pd.date_range("2011-01-01", freq="D", periods=10)).__getattr__(item)
-
-    def test_multi_index_getattr(self):
-        arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]]
-        idx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        pdf = pd.DataFrame(np.random.randn(4, 5), idx)
-        psdf = ps.from_pandas(pdf)
-        psidx = psdf.index
-        item = "databricks"
-
-        expected_error_message = "'MultiIndex' object has no attribute '{}'".format(item)
-        with self.assertRaisesRegex(AttributeError, expected_error_message):
-            psidx.__getattr__(item)
-
-    def test_to_series(self):
-        pidx = self.pdf.index
-        psidx = self.psdf.index
-
-        self.assert_eq(psidx.to_series(), pidx.to_series())
-        self.assert_eq(psidx.to_series(name="a"), pidx.to_series(name="a"))
-
-        # With name
-        pidx.name = "Koalas"
-        psidx.name = "Koalas"
-        self.assert_eq(psidx.to_series(), pidx.to_series())
-        self.assert_eq(psidx.to_series(name=("x", "a")), pidx.to_series(name=("x", "a")))
-
-        # With tupled name
-        pidx.name = ("x", "a")
-        psidx.name = ("x", "a")
-        self.assert_eq(psidx.to_series(), pidx.to_series())
-        self.assert_eq(psidx.to_series(name="a"), pidx.to_series(name="a"))
-
-        self.assert_eq((psidx + 1).to_series(), (pidx + 1).to_series())
-
-        pidx = self.pdf.set_index("b", append=True).index
-        psidx = self.psdf.set_index("b", append=True).index
-
-        with self.sql_conf({SPARK_CONF_ARROW_ENABLED: False}):
-            self.assert_eq(psidx.to_series(), pidx.to_series())
-            self.assert_eq(psidx.to_series(name="a"), pidx.to_series(name="a"))
-
-        expected_error_message = "Series.name must be a hashable type"
-        with self.assertRaisesRegex(TypeError, expected_error_message):
-            psidx.to_series(name=["x", "a"])
-
-    def test_to_frame(self):
-        pidx = self.pdf.index
-        psidx = self.psdf.index
-
-        self.assert_eq(psidx.to_frame(), pidx.to_frame())
-        self.assert_eq(psidx.to_frame(index=False), pidx.to_frame(index=False))
-
-        pidx.name = "a"
-        psidx.name = "a"
-
-        self.assert_eq(psidx.to_frame(), pidx.to_frame())
-        self.assert_eq(psidx.to_frame(index=False), pidx.to_frame(index=False))
-
-        self.assert_eq(psidx.to_frame(name="x"), pidx.to_frame(name="x"))
-        self.assert_eq(psidx.to_frame(index=False, name="x"), pidx.to_frame(index=False, name="x"))
-
-        self.assertRaises(TypeError, lambda: psidx.to_frame(name=["x"]))
-
-        # non-string name
-        self.assert_eq(psidx.to_frame(name=10), pidx.to_frame(name=10))
-        self.assert_eq(psidx.to_frame(name=("x", 10)), pidx.to_frame(name=("x", 10)))
-
-        pidx = self.pdf.set_index("b", append=True).index
-        psidx = self.psdf.set_index("b", append=True).index
-
-        self.assert_eq(psidx.to_frame(), pidx.to_frame())
-        self.assert_eq(psidx.to_frame(index=False), pidx.to_frame(index=False))
-
-        self.assert_eq(psidx.to_frame(name=["x", "y"]), pidx.to_frame(name=["x", "y"]))
-        self.assert_eq(psidx.to_frame(name=("x", "y")), pidx.to_frame(name=("x", "y")))
-        self.assert_eq(
-            psidx.to_frame(index=False, name=["x", "y"]),
-            pidx.to_frame(index=False, name=["x", "y"]),
-        )
-
-        self.assertRaises(TypeError, lambda: psidx.to_frame(name="x"))
-        self.assertRaises(ValueError, lambda: psidx.to_frame(name=["x"]))
-
-        # non-string names
-        self.assert_eq(psidx.to_frame(name=[10, 20]), pidx.to_frame(name=[10, 20]))
-        self.assert_eq(psidx.to_frame(name=("x", 10)), pidx.to_frame(name=("x", 10)))
-        if LooseVersion(pd.__version__) < LooseVersion("1.5.0"):
-            self.assert_eq(
-                psidx.to_frame(name=[("x", 10), ("y", 20)]),
-                pidx.to_frame(name=[("x", 10), ("y", 20)]),
-            )
-        else:
-            # Since pandas 1.5.0, the result is changed as below:
-            #      (x, 10)  (y, 20)
-            #   b
-            # 0 4        0        4
-            # 1 5        1        5
-            # 3 6        3        6
-            # 5 3        5        3
-            # 6 2        6        2
-            # 8 1        8        1
-            # 9 0        9        0
-            #   0        9        0
-            #   0        9        0
-            #
-            # The columns should be `Index([('x', 20), ('y', 20)], dtype='object')`,
-            # but pandas API on Spark doesn't support such a way for creating Index.
-            # So, we currently cannot follow the behavior of pandas.
-            expected_result = ps.DataFrame(
-                {("x", 10): [0, 1, 3, 5, 6, 8, 9, 9, 9], ("y", 20): [4, 5, 6, 3, 2, 1, 0, 0, 0]},
-                index=ps.MultiIndex.from_tuples(
-                    [(0, 4), (1, 5), (3, 6), (5, 3), (6, 2), (8, 1), (9, 0), (9, 0), (9, 0)],
-                    names=[None, "b"],
-                ),
-            )
-            self.assert_eq(psidx.to_frame(name=[("x", 10), ("y", 20)]), expected_result)
-
-    def test_index_names(self):
-        psdf = self.psdf
-        self.assertIsNone(psdf.index.name)
-
-        idx = pd.Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], name="x")
-        pdf = pd.DataFrame(np.random.randn(10, 5), index=idx, columns=list("abcde"))
-        psdf = ps.from_pandas(pdf)
-
-        pser = pdf.a
-        psser = psdf.a
-
-        self.assertEqual(psdf.index.name, pdf.index.name)
-        self.assertEqual(psdf.index.names, pdf.index.names)
-
-        pidx = pdf.index
-        psidx = psdf.index
-        pidx.name = "renamed"
-        psidx.name = "renamed"
-        self.assertEqual(psidx.name, pidx.name)
-        self.assertEqual(psidx.names, pidx.names)
-        self.assert_eq(psidx, pidx)
-        self.assertEqual(psdf.index.name, pdf.index.name)
-        self.assertEqual(psdf.index.names, pdf.index.names)
-        self.assertEqual(psser.index.names, pser.index.names)
-
-        pidx.name = None
-        psidx.name = None
-        self.assertEqual(psidx.name, pidx.name)
-        self.assertEqual(psidx.names, pidx.names)
-        self.assert_eq(psidx, pidx)
-        self.assertEqual(psdf.index.name, pdf.index.name)
-        self.assertEqual(psdf.index.names, pdf.index.names)
-        self.assertEqual(psser.index.names, pser.index.names)
-
-        with self.assertRaisesRegex(ValueError, "Names must be a list-like"):
-            psidx.names = "hi"
-
-        expected_error_message = "Length of new names must be {}, got {}".format(
-            psdf._internal.index_level, len(["0", "1"])
-        )
-        with self.assertRaisesRegex(ValueError, expected_error_message):
-            psidx.names = ["0", "1"]
-
-        expected_error_message = "Index.name must be a hashable type"
-        with self.assertRaisesRegex(TypeError, expected_error_message):
-            ps.Index([1, 2, 3], name=["0", "1"])
-        with self.assertRaisesRegex(TypeError, expected_error_message):
-            psidx.name = ["renamed"]
-        with self.assertRaisesRegex(TypeError, expected_error_message):
-            psidx.name = ["0", "1"]
-        # Specifying `names` when creating Index is no longer supported from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            pass
-        else:
-            with self.assertRaisesRegex(TypeError, expected_error_message):
-                ps.Index([(1, 2), (3, 4)], names=["a", ["b"]])
-
-    def test_multi_index_names(self):
-        arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]]
-        idx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        pdf = pd.DataFrame(np.random.randn(4, 5), idx)
-        psdf = ps.from_pandas(pdf)
-
-        self.assertEqual(psdf.index.names, pdf.index.names)
-
-        pidx = pdf.index
-        psidx = psdf.index
-        pidx.names = ["renamed_number", "renamed_color"]
-        psidx.names = ["renamed_number", "renamed_color"]
-        self.assertEqual(psidx.names, pidx.names)
-
-        pidx.names = ["renamed_number", None]
-        psidx.names = ["renamed_number", None]
-        self.assertEqual(psidx.names, pidx.names)
-        self.assert_eq(psidx, pidx)
-
-        with self.assertRaises(PandasNotImplementedError):
-            psidx.name
-        with self.assertRaises(PandasNotImplementedError):
-            psidx.name = "renamed"
-
-    def test_index_rename(self):
-        pdf = pd.DataFrame(
-            np.random.randn(10, 5), index=pd.Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], name="x")
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pidx = pdf.index
-        psidx = psdf.index
-
-        self.assert_eq(psidx.rename("y"), pidx.rename("y"))
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        # non-string names
-        self.assert_eq(psidx.rename(0), pidx.rename(0))
-        self.assert_eq(psidx.rename(("y", 0)), pidx.rename(("y", 0)))
-
-        psidx.rename("z", inplace=True)
-        pidx.rename("z", inplace=True)
-
-        self.assert_eq(psidx, pidx)
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        self.assert_eq(psidx.rename(None), pidx.rename(None))
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        self.assertRaises(TypeError, lambda: psidx.rename(["x", "y"]))
-
-    def test_multi_index_rename(self):
-        arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]]
-        idx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        pdf = pd.DataFrame(np.random.randn(4, 5), idx)
-        psdf = ps.from_pandas(pdf)
-
-        pmidx = pdf.index
-        psmidx = psdf.index
-
-        self.assert_eq(psmidx.rename(["n", "c"]), pmidx.rename(["n", "c"]))
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        # non-string names
-        self.assert_eq(psmidx.rename([0, 1]), pmidx.rename([0, 1]))
-        self.assert_eq(
-            psmidx.rename([("x", "a"), ("y", "b")]), pmidx.rename([("x", "a"), ("y", "b")])
-        )
-
-        psmidx.rename(["num", "col"], inplace=True)
-        pmidx.rename(["num", "col"], inplace=True)
-
-        self.assert_eq(psmidx, pmidx)
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        self.assert_eq(psmidx.rename([None, None]), pmidx.rename([None, None]))
-        self.assert_eq(psdf.index.names, pdf.index.names)
-
-        self.assertRaises(TypeError, lambda: psmidx.rename("number"))
-        self.assertRaises(TypeError, lambda: psmidx.rename(None))
-        self.assertRaises(ValueError, lambda: psmidx.rename(["number"]))
-
-    def test_multi_index_levshape(self):
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2)])
-        psidx = ps.from_pandas(pidx)
-        self.assertEqual(pidx.levshape, psidx.levshape)
-
-    def test_index_unique(self):
-        psidx = self.psdf.index
-
-        # here the output is different than pandas in terms of order
-        expected = [0, 1, 3, 5, 6, 8, 9]
-
-        self.assert_eq(expected, sorted(psidx.unique()._to_pandas()))
-        self.assert_eq(expected, sorted(psidx.unique(level=0)._to_pandas()))
-
-        expected = [1, 2, 4, 6, 7, 9, 10]
-        self.assert_eq(expected, sorted((psidx + 1).unique()._to_pandas()))
-
-        with self.assertRaisesRegex(IndexError, "Too many levels*"):
-            psidx.unique(level=1)
-
-        with self.assertRaisesRegex(KeyError, "Requested level (hi)*"):
-            psidx.unique(level="hi")
-
-    def test_multi_index_copy(self):
-        arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]]
-        idx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        pdf = pd.DataFrame(np.random.randn(4, 5), idx)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.index.copy(), pdf.index.copy())
-
-    def test_drop_duplicates(self):
-        pidx = pd.Index([4, 2, 4, 1, 4, 3])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.drop_duplicates(), pidx.drop_duplicates())
-        self.assert_eq((psidx + 1).drop_duplicates(), (pidx + 1).drop_duplicates())
-
-        self.assert_eq(psidx.drop_duplicates(keep="first"), pidx.drop_duplicates(keep="first"))
-        self.assert_eq(psidx.drop_duplicates(keep="last"), pidx.drop_duplicates(keep="last"))
-        self.assert_eq(psidx.drop_duplicates(keep=False), pidx.drop_duplicates(keep=False))
-
-        arrays = [[1, 2, 3, 1, 2], ["red", "blue", "black", "red", "blue"]]
-        pmidx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(psmidx.drop_duplicates(), pmidx.drop_duplicates())
-        self.assert_eq(psmidx.drop_duplicates(keep="first"), pmidx.drop_duplicates(keep="first"))
-        self.assert_eq(psmidx.drop_duplicates(keep="last"), pmidx.drop_duplicates(keep="last"))
-        self.assert_eq(psmidx.drop_duplicates(keep=False), pmidx.drop_duplicates(keep=False))
-
-    def test_dropna(self):
-        pidx = pd.Index([np.nan, 2, 4, 1, None, 3])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.dropna(), pidx.dropna())
-        self.assert_eq((psidx + 1).dropna(), (pidx + 1).dropna())
-
-        self.assert_eq(psidx.dropna(how="any"), pidx.dropna(how="any"))
-        self.assert_eq(psidx.dropna(how="all"), pidx.dropna(how="all"))
-
-        pmidx = pd.MultiIndex.from_tuples(
-            [(np.nan, 1.0), (2.0, 2.0), (np.nan, None), (3.0, np.nan)]
-        )
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(psmidx.dropna(), pmidx.dropna())
-        self.assert_eq(psmidx.dropna(how="any"), pmidx.dropna(how="any"))
-        self.assert_eq(psmidx.dropna(how="all"), pmidx.dropna(how="all"))
-
-        invalid_how = "none"
-        with self.assertRaisesRegex(ValueError, "invalid how option: %s" % invalid_how):
-            psmidx.dropna(invalid_how)
-
-    def test_index_symmetric_difference(self):
-        pidx1 = pd.Index([1, 2, 3, 4])
-        pidx2 = pd.Index([2, 3, 4, 5])
-        psidx1 = ps.from_pandas(pidx1)
-        psidx2 = ps.from_pandas(pidx2)
-
-        self.assert_eq(
-            psidx1.symmetric_difference(psidx2).sort_values(),
-            pidx1.symmetric_difference(pidx2).sort_values(),
-        )
-        self.assert_eq(
-            (psidx1 + 1).symmetric_difference(psidx2).sort_values(),
-            (pidx1 + 1).symmetric_difference(pidx2).sort_values(),
-        )
-        # No longer supported from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                (psidx1 ^ psidx2).sort_values(),
-                ps.Index([1, 5], dtype="int64"),
-            )
-        else:
-            self.assert_eq(
-                (psidx1 ^ psidx2).sort_values(),
-                (pidx1 ^ pidx2).sort_values(),
-            )
-        self.assert_eq(
-            psidx1.symmetric_difference(psidx2, result_name="result").sort_values(),
-            pidx1.symmetric_difference(pidx2, result_name="result").sort_values(),
-        )
-
-        pmidx1 = pd.MultiIndex(
-            [["lama", "cow", "falcon"], ["speed", "weight", "length"]],
-            [[0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 0, 0, 0, 1, 2, 0, 1, 2]],
-        )
-        pmidx2 = pd.MultiIndex(
-            [["koalas", "cow", "falcon"], ["speed", "weight", "length"]],
-            [[0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 0, 0, 0, 1, 2, 0, 1, 2]],
-        )
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-
-        self.assert_eq(
-            psmidx1.symmetric_difference(psmidx2).sort_values(),
-            pmidx1.symmetric_difference(pmidx2).sort_values(),
-        )
-
-        # Pandas has a bug that raise TypeError when setting `result_name` for MultiIndex.
-        pandas_result = pmidx1.symmetric_difference(pmidx2)
-        pandas_result.names = ["a", "b"]
-        self.assert_eq(
-            psmidx1.symmetric_difference(psmidx2, result_name=["a", "b"]).sort_values(),
-            pandas_result,
-        )
-
-        # Pandas sort the result by default, so doesn't provide the `True` for sort.
-        self.assert_eq(
-            psmidx1.symmetric_difference(psmidx2, sort=True),
-            pmidx1.symmetric_difference(pmidx2),
-        )
-
-        idx = ps.Index(["a", "b", "c"])
-        midx = ps.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-
-        with self.assertRaisesRegex(NotImplementedError, "Doesn't support*"):
-            idx.symmetric_difference(midx)
-
-    def test_multi_index_symmetric_difference(self):
-        idx = ps.Index(["a", "b", "c"])
-        midx = ps.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        midx_ = ps.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-
-        self.assert_eq(
-            midx.symmetric_difference(midx_),
-            midx._to_pandas().symmetric_difference(midx_._to_pandas()),
-        )
-
-        with self.assertRaisesRegex(NotImplementedError, "Doesn't support*"):
-            midx.symmetric_difference(idx)
-
-    def test_missing(self):
-        psdf = ps.DataFrame(
-            {
-                "a": [1, 2, 3],
-                "b": [4, 5, 6],
-                "c": pd.date_range("2011-01-01", freq="D", periods=3),
-                "d": pd.Categorical(["a", "b", "c"]),
-                "e": [timedelta(1), timedelta(2), timedelta(3)],
-            }
-        )
-
-        # Index functions
-        missing_functions = inspect.getmembers(MissingPandasLikeIndex, inspect.isfunction)
-        unsupported_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "unsupported_function"
-        ]
-        for name in unsupported_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "method.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("a").index, name)()
-
-        deprecated_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "deprecated_function"
-        ]
-        for name in deprecated_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "method.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index("a").index, name)()
-
-        # MultiIndex functions
-        missing_functions = inspect.getmembers(MissingPandasLikeMultiIndex, inspect.isfunction)
-        unsupported_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "unsupported_function"
-        ]
-        for name in unsupported_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "method.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index(["a", "b"]).index, name)()
-
-        deprecated_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "deprecated_function"
-        ]
-        for name in deprecated_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "method.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index(["a", "b"]).index, name)()
-
-        # DatetimeIndex functions
-        missing_functions = inspect.getmembers(MissingPandasLikeDatetimeIndex, inspect.isfunction)
-        unsupported_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "unsupported_function"
-        ]
-        for name in unsupported_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "method.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("c").index, name)()
-
-        deprecated_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "deprecated_function"
-        ]
-        for name in deprecated_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "method.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index("c").index, name)()
-
-        # TimedeltaIndex functions
-        missing_functions = inspect.getmembers(MissingPandasLikeTimedeltaIndex, inspect.isfunction)
-        unsupported_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "unsupported_function"
-        ]
-        for name in unsupported_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "method.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("e").index, name)()
-
-        deprecated_functions = [
-            name for (name, type_) in missing_functions if type_.__name__ == "deprecated_function"
-        ]
-        for name in deprecated_functions:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "method.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index("e").index, name)()
-
-        # Index properties
-        missing_properties = inspect.getmembers(
-            MissingPandasLikeIndex, lambda o: isinstance(o, property)
-        )
-        unsupported_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "unsupported_property"
-        ]
-        for name in unsupported_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "property.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("a").index, name)
-
-        deprecated_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "deprecated_property"
-        ]
-        for name in deprecated_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "property.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index("a").index, name)
-
-        # MultiIndex properties
-        missing_properties = inspect.getmembers(
-            MissingPandasLikeMultiIndex, lambda o: isinstance(o, property)
-        )
-        unsupported_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "unsupported_property"
-        ]
-        for name in unsupported_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "property.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index(["a", "b"]).index, name)
-
-        deprecated_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "deprecated_property"
-        ]
-        for name in deprecated_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError, "property.*Index.*{}.*is deprecated".format(name)
-            ):
-                getattr(psdf.set_index(["a", "b"]).index, name)
-
-        # DatetimeIndex properties
-        missing_properties = inspect.getmembers(
-            MissingPandasLikeDatetimeIndex, lambda o: isinstance(o, property)
-        )
-        unsupported_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "unsupported_property"
-        ]
-        for name in unsupported_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "property.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("c").index, name)
-
-        # TimedeltaIndex properties
-        missing_properties = inspect.getmembers(
-            MissingPandasLikeDatetimeIndex, lambda o: isinstance(o, property)
-        )
-        unsupported_properties = [
-            name
-            for (name, type_) in missing_properties
-            if type_.fget.__name__ == "unsupported_property"
-        ]
-        for name in unsupported_properties:
-            with self.assertRaisesRegex(
-                PandasNotImplementedError,
-                "property.*Index.*{}.*not implemented( yet\\.|\\. .+)".format(name),
-            ):
-                getattr(psdf.set_index("c").index, name)
-
-    def test_index_has_duplicates(self):
-        indexes = [("a", "b", "c"), ("a", "a", "c"), (1, 3, 3), (1, 2, 3)]
-        names = [None, "ks", "ks", None]
-        has_dup = [False, True, True, False]
-
-        for idx, name, expected in zip(indexes, names, has_dup):
-            pdf = pd.DataFrame({"a": [1, 2, 3]}, index=pd.Index(idx, name=name))
-            psdf = ps.from_pandas(pdf)
-
-            self.assertEqual(psdf.index.has_duplicates, expected)
-
-    def test_multiindex_has_duplicates(self):
-        indexes = [
-            [list("abc"), list("edf")],
-            [list("aac"), list("edf")],
-            [list("aac"), list("eef")],
-            [[1, 4, 4], [4, 6, 6]],
-        ]
-        has_dup = [False, False, True, True]
-
-        for idx, expected in zip(indexes, has_dup):
-            pdf = pd.DataFrame({"a": [1, 2, 3]}, index=idx)
-            psdf = ps.from_pandas(pdf)
-
-            self.assertEqual(psdf.index.has_duplicates, expected)
-
-    def test_multi_index_not_supported(self):
-        psdf = ps.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
-
-        with self.assertRaisesRegex(TypeError, "cannot perform any with this index type"):
-            psdf.set_index(["a", "b"]).index.any()
-
-        with self.assertRaisesRegex(TypeError, "cannot perform all with this index type"):
-            psdf.set_index(["a", "b"]).index.all()
-
-    def test_index_nlevels(self):
-        pdf = pd.DataFrame({"a": [1, 2, 3]}, index=pd.Index(["a", "b", "c"]))
-        psdf = ps.from_pandas(pdf)
-
-        self.assertEqual(psdf.index.nlevels, 1)
-
-    def test_multiindex_nlevel(self):
-        pdf = pd.DataFrame({"a": [1, 2, 3]}, index=[list("abc"), list("def")])
-        psdf = ps.from_pandas(pdf)
-
-        self.assertEqual(psdf.index.nlevels, 2)
-
-    def test_multiindex_from_arrays(self):
-        arrays = [["a", "a", "b", "b"], ["red", "blue", "red", "blue"]]
-        pidx = pd.MultiIndex.from_arrays(arrays)
-        psidx = ps.MultiIndex.from_arrays(arrays)
-
-        self.assert_eq(pidx, psidx)
-
-    def test_multiindex_swaplevel(self):
-        pidx = pd.MultiIndex.from_arrays([["a", "b"], [1, 2]])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.swaplevel(0, 1), psidx.swaplevel(0, 1))
-
-        pidx = pd.MultiIndex.from_arrays([["a", "b"], [1, 2]], names=["word", "number"])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.swaplevel(0, 1), psidx.swaplevel(0, 1))
-
-        pidx = pd.MultiIndex.from_arrays([["a", "b"], [1, 2]], names=["word", None])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.swaplevel(-2, -1), psidx.swaplevel(-2, -1))
-        self.assert_eq(pidx.swaplevel(0, 1), psidx.swaplevel(0, 1))
-        self.assert_eq(pidx.swaplevel("word", 1), psidx.swaplevel("word", 1))
-
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index"):
-            psidx.swaplevel(-3, "word")
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index"):
-            psidx.swaplevel(0, 2)
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index"):
-            psidx.swaplevel(0, -3)
-        with self.assertRaisesRegex(KeyError, "Level work not found"):
-            psidx.swaplevel(0, "work")
-
-    def test_multiindex_droplevel(self):
-        pidx = pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("b", "y", 2)], names=["level1", "level2", "level3"]
-        )
-        psidx = ps.from_pandas(pidx)
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index has only 3 levels, not 5"):
-            psidx.droplevel(4)
-
-        with self.assertRaisesRegex(KeyError, "Level level4 not found"):
-            psidx.droplevel("level4")
-
-        with self.assertRaisesRegex(KeyError, "Level.*level3.*level4.*not found"):
-            psidx.droplevel([("level3", "level4")])
-
-        with self.assertRaisesRegex(
-            ValueError,
-            "Cannot remove 4 levels from an index with 3 levels: at least one "
-            "level must be left.",
-        ):
-            psidx.droplevel([0, 0, 1, 2])
-
-        with self.assertRaisesRegex(
-            ValueError,
-            "Cannot remove 3 levels from an index with 3 levels: at least one "
-            "level must be left.",
-        ):
-            psidx.droplevel([0, 1, 2])
-
-        self.assert_eq(pidx.droplevel(0), psidx.droplevel(0))
-        self.assert_eq(pidx.droplevel([0, 1]), psidx.droplevel([0, 1]))
-        self.assert_eq(pidx.droplevel((0, 1)), psidx.droplevel((0, 1)))
-        self.assert_eq(pidx.droplevel([0, "level2"]), psidx.droplevel([0, "level2"]))
-        self.assert_eq(pidx.droplevel((0, "level2")), psidx.droplevel((0, "level2")))
-
-        # non-string names
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2)], names=[1.0, 2.0, 3.0])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.droplevel(1.0), psidx.droplevel(1.0))
-        self.assert_eq(pidx.droplevel([0, 2.0]), psidx.droplevel([0, 2.0]))
-
-    def test_index_fillna(self):
-        pidx = pd.Index([1, 2, None])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.fillna(0), psidx.fillna(0), almost=True)
-        self.assert_eq(pidx.rename("name").fillna(0), psidx.rename("name").fillna(0), almost=True)
-
-        with self.assertRaisesRegex(TypeError, "Unsupported type list"):
-            psidx.fillna([1, 2])
-
-    def test_index_drop(self):
-        pidx = pd.Index([1, 2, 3])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.drop(1), psidx.drop(1))
-        self.assert_eq(pidx.drop([1, 2]), psidx.drop([1, 2]))
-        self.assert_eq((pidx + 1).drop([2, 3]), (psidx + 1).drop([2, 3]))
-
-    def test_multiindex_drop(self):
-        pidx = pd.MultiIndex.from_tuples(
-            [("a", "x"), ("b", "y"), ("c", "z")], names=["level1", "level2"]
-        )
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.drop("a"), psidx.drop("a"))
-        self.assert_eq(pidx.drop(["a", "b"]), psidx.drop(["a", "b"]))
-        self.assert_eq(pidx.drop(["x", "y"], level=1), psidx.drop(["x", "y"], level=1))
-        self.assert_eq(
-            pidx.drop(["x", "y"], level="level2"), psidx.drop(["x", "y"], level="level2")
-        )
-
-        pidx.names = ["lv1", "lv2"]
-        psidx.names = ["lv1", "lv2"]
-        self.assert_eq(pidx.drop(["x", "y"], level="lv2"), psidx.drop(["x", "y"], level="lv2"))
-
-        self.assertRaises(IndexError, lambda: psidx.drop(["a", "b"], level=2))
-        self.assertRaises(KeyError, lambda: psidx.drop(["a", "b"], level="level"))
-
-        psidx.names = ["lv", "lv"]
-        self.assertRaises(ValueError, lambda: psidx.drop(["x", "y"], level="lv"))
-
-    def _test_sort_values(self, pidx, psidx):
-        self.assert_eq(pidx.sort_values(), psidx.sort_values())
-        # Parameter ascending
-        self.assert_eq(pidx.sort_values(ascending=False), psidx.sort_values(ascending=False))
-        # Parameter return_indexer
-        p_sorted, p_indexer = pidx.sort_values(return_indexer=True)
-        ps_sorted, ps_indexer = psidx.sort_values(return_indexer=True)
-        self.assert_eq(p_sorted, ps_sorted)
-        self.assert_eq(p_indexer, ps_indexer.to_list())
-        self.assert_eq(
-            pidx.sort_values(return_indexer=False), psidx.sort_values(return_indexer=False)
-        )
-        # Parameter return_indexer and ascending
-        p_sorted, p_indexer = pidx.sort_values(return_indexer=True, ascending=False)
-        ps_sorted, ps_indexer = psidx.sort_values(return_indexer=True, ascending=False)
-        self.assert_eq(p_sorted, ps_sorted)
-        self.assert_eq(p_indexer, ps_indexer.to_list())
-        self.assert_eq(
-            pidx.sort_values(return_indexer=False, ascending=False),
-            psidx.sort_values(return_indexer=False, ascending=False),
-        )
-
-    def test_sort_values(self):
-        pidx = pd.Index([-10, -100, 200, 100])
-        psidx = ps.from_pandas(pidx)
-
-        self._test_sort_values(pidx, psidx)
-
-        pidx.name = "koalas"
-        psidx.name = "koalas"
-
-        self._test_sort_values(pidx, psidx)
-
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psidx = ps.from_pandas(pidx)
-
-        pidx.names = ["hello", "koalas", "goodbye"]
-        psidx.names = ["hello", "koalas", "goodbye"]
-
-        self._test_sort_values(pidx, psidx)
-
-    def test_index_drop_duplicates(self):
-        pidx = pd.Index([1, 1, 2])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.drop_duplicates().sort_values(), psidx.drop_duplicates().sort_values())
-
-        pidx = pd.MultiIndex.from_tuples([(1, 1), (1, 1), (2, 2)], names=["level1", "level2"])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.drop_duplicates().sort_values(), psidx.drop_duplicates().sort_values())
-
-    def test_index_sort(self):
-        idx = ps.Index([1, 2, 3, 4, 5])
-        midx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2)])
-
-        with self.assertRaisesRegex(
-            TypeError, "cannot sort an Index object in-place, use sort_values instead"
-        ):
-            idx.sort()
-        with self.assertRaisesRegex(
-            TypeError, "cannot sort an Index object in-place, use sort_values instead"
-        ):
-            midx.sort()
-
-    def test_multiindex_isna(self):
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-
-        with self.assertRaisesRegex(NotImplementedError, "isna is not defined for MultiIndex"):
-            psidx.isna()
-
-        with self.assertRaisesRegex(NotImplementedError, "isna is not defined for MultiIndex"):
-            psidx.isnull()
-
-        with self.assertRaisesRegex(NotImplementedError, "notna is not defined for MultiIndex"):
-            psidx.notna()
-
-        with self.assertRaisesRegex(NotImplementedError, "notna is not defined for MultiIndex"):
-            psidx.notnull()
-
-    def test_index_nunique(self):
-        pidx = pd.Index([1, 1, 2, None])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.nunique(), psidx.nunique())
-        self.assert_eq(pidx.nunique(dropna=True), psidx.nunique(dropna=True))
-
-    def test_multiindex_nunique(self):
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        with self.assertRaisesRegex(NotImplementedError, "notna is not defined for MultiIndex"):
-            psidx.notnull()
-
-    def test_multiindex_rename(self):
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psidx = ps.from_pandas(pidx)
-
-        pidx = pidx.rename(list("ABC"))
-        psidx = psidx.rename(list("ABC"))
-        self.assert_eq(pidx, psidx)
-
-        pidx = pidx.rename(["my", "name", "is"])
-        psidx = psidx.rename(["my", "name", "is"])
-        self.assert_eq(pidx, psidx)
-
-    def test_multiindex_set_names(self):
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psidx = ps.from_pandas(pidx)
-
-        pidx = pidx.set_names(["set", "new", "names"])
-        psidx = psidx.set_names(["set", "new", "names"])
-        self.assert_eq(pidx, psidx)
-
-        pidx.set_names(["set", "new", "names"], inplace=True)
-        psidx.set_names(["set", "new", "names"], inplace=True)
-        self.assert_eq(pidx, psidx)
-
-        pidx = pidx.set_names("first", level=0)
-        psidx = psidx.set_names("first", level=0)
-        self.assert_eq(pidx, psidx)
-
-        pidx = pidx.set_names("second", level=1)
-        psidx = psidx.set_names("second", level=1)
-        self.assert_eq(pidx, psidx)
-
-        pidx = pidx.set_names("third", level=2)
-        psidx = psidx.set_names("third", level=2)
-        self.assert_eq(pidx, psidx)
-
-        pidx.set_names("first", level=0, inplace=True)
-        psidx.set_names("first", level=0, inplace=True)
-        self.assert_eq(pidx, psidx)
-
-        pidx.set_names("second", level=1, inplace=True)
-        psidx.set_names("second", level=1, inplace=True)
-        self.assert_eq(pidx, psidx)
-
-        pidx.set_names("third", level=2, inplace=True)
-        psidx.set_names("third", level=2, inplace=True)
-        self.assert_eq(pidx, psidx)
-
-    def test_multiindex_from_tuples(self):
-        tuples = [(1, "red"), (1, "blue"), (2, "red"), (2, "blue")]
-        pidx = pd.MultiIndex.from_tuples(tuples)
-        psidx = ps.MultiIndex.from_tuples(tuples)
-
-        self.assert_eq(pidx, psidx)
-
-    def test_multiindex_from_product(self):
-        iterables = [[0, 1, 2], ["green", "purple"]]
-        pidx = pd.MultiIndex.from_product(iterables)
-        psidx = ps.MultiIndex.from_product(iterables)
-
-        self.assert_eq(pidx, psidx)
-
-    def test_multiindex_tuple_column_name(self):
-        column_labels = pd.MultiIndex.from_tuples([("a", "x"), ("a", "y"), ("b", "z")])
-        pdf = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=column_labels)
-        pdf.set_index(("a", "x"), append=True, inplace=True)
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(pdf, psdf)
-
-    def test_len(self):
-        pidx = pd.Index(range(10000))
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(len(pidx), len(psidx))
-
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-
-        self.assert_eq(len(pidx), len(psidx))
-
-    def test_delete(self):
-        pidx = pd.Index([10, 9, 8, 7, 6, 7, 8, 9, 10])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.delete(8).sort_values(), psidx.delete(8).sort_values())
-        self.assert_eq(pidx.delete(-9).sort_values(), psidx.delete(-9).sort_values())
-        self.assert_eq(
-            pidx.delete([-9, 0, 8]).sort_values(), psidx.delete([-9, 0, 8]).sort_values()
-        )
-
-        with self.assertRaisesRegex(IndexError, "index 9 is out of bounds for axis 0 with size 9"):
-            psidx.delete([0, 9])
-        with self.assertRaisesRegex(
-            IndexError, "index -10 is out of bounds for axis 0 with size 9"
-        ):
-            psidx.delete([-10, 0])
-        with self.assertRaisesRegex(IndexError, "index 9 is out of bounds for axis 0 with size 9"):
-            psidx.delete(9)
-        with self.assertRaisesRegex(
-            IndexError, "index -10 is out of bounds for axis 0 with size 9"
-        ):
-            psidx.delete(-10)
-
-        # MultiIndex
-        pidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-
-        self.assert_eq(pidx.delete(2).sort_values(), psidx.delete(2).sort_values())
-        self.assert_eq(pidx.delete(-3).sort_values(), psidx.delete(-3).sort_values())
-        self.assert_eq(
-            pidx.delete([-3, 0, 2]).sort_values(), psidx.delete([-3, 0, 2]).sort_values()
-        )
-
-        with self.assertRaisesRegex(IndexError, "index 3 is out of bounds for axis 0 with size 3"):
-            psidx.delete([0, 3])
-        with self.assertRaisesRegex(IndexError, "index -4 is out of bounds for axis 0 with size 3"):
-            psidx.delete([-4, 0])
-        with self.assertRaisesRegex(IndexError, "index 3 is out of bounds for axis 0 with size 3"):
-            psidx.delete(3)
-        with self.assertRaisesRegex(IndexError, "index -4 is out of bounds for axis 0 with size 3"):
-            psidx.delete(-4)
-
-    def test_append(self):
-        # Index
-        pidx = pd.Index(range(10000))
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.append(pidx), psidx.append(psidx))
-
-        # Index with name
-        pidx1 = pd.Index(range(10000), name="a")
-        pidx2 = pd.Index(range(10000), name="b")
-        psidx1 = ps.from_pandas(pidx1)
-        psidx2 = ps.from_pandas(pidx2)
-
-        self.assert_eq(pidx1.append(pidx2), psidx1.append(psidx2))
-
-        self.assert_eq(pidx2.append(pidx1), psidx2.append(psidx1))
-
-        # Index from DataFrame
-        pdf1 = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
-        pdf2 = pd.DataFrame({"a": [7, 8, 9], "d": [10, 11, None]}, index=["x", "y", "z"])
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        pidx1 = pdf1.set_index("a").index
-        pidx2 = pdf2.set_index("d").index
-        psidx1 = psdf1.set_index("a").index
-        psidx2 = psdf2.set_index("d").index
-
-        self.assert_eq(pidx1.append(pidx2), psidx1.append(psidx2))
-
-        self.assert_eq(pidx2.append(pidx1), psidx2.append(psidx1))
-
-        # Index from DataFrame with MultiIndex columns
-        pdf1 = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
-        pdf2 = pd.DataFrame({"a": [7, 8, 9], "d": [10, 11, 12]})
-        pdf1.columns = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y")])
-        pdf2.columns = pd.MultiIndex.from_tuples([("a", "x"), ("d", "y")])
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        pidx1 = pdf1.set_index(("a", "x")).index
-        pidx2 = pdf2.set_index(("d", "y")).index
-        psidx1 = psdf1.set_index(("a", "x")).index
-        psidx2 = psdf2.set_index(("d", "y")).index
-
-        self.assert_eq(pidx1.append(pidx2), psidx1.append(psidx2))
-
-        self.assert_eq(pidx2.append(pidx1), psidx2.append(psidx1))
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pmidx.append(pmidx), psmidx.append(psmidx))
-
-        # MultiIndex with names
-        pmidx1 = pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("b", "y", 2), ("c", "z", 3)], names=["x", "y", "z"]
-        )
-        pmidx2 = pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("b", "y", 2), ("c", "z", 3)], names=["p", "q", "r"]
-        )
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-
-        # TODO(SPARK-43241): MultiIndex.append not checking names for equality.
-        # Also refer to https://github.com/pandas-dev/pandas/pull/48288.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                pmidx1.append(pmidx2), psmidx1.append(psmidx2).rename([None, None, None])
-            )
-        else:
-            self.assert_eq(pmidx1.append(pmidx2), psmidx1.append(psmidx2))
-
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                pmidx2.append(pmidx1), psmidx2.append(psmidx1).rename([None, None, None])
-            )
-        else:
-            self.assert_eq(pmidx2.append(pmidx1), psmidx2.append(psmidx1))
-
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                pmidx1.append(pmidx2).names,
-                psmidx1.append(psmidx2).rename([None, None, None]).names,
-            )
-        else:
-            self.assert_eq(pmidx1.append(pmidx2).names, psmidx1.append(psmidx2).names)
-
-        # Index & MultiIndex is currently not supported
-        expected_error_message = r"append\(\) between Index & MultiIndex is currently not supported"
-        with self.assertRaisesRegex(NotImplementedError, expected_error_message):
-            psidx.append(psmidx)
-        with self.assertRaisesRegex(NotImplementedError, expected_error_message):
-            psmidx.append(psidx)
-
-        # MultiIndexs with different levels is currently not supported
-        psmidx3 = ps.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        expected_error_message = (
-            r"append\(\) between MultiIndexs with different levels is currently not supported"
-        )
-        with self.assertRaisesRegex(NotImplementedError, expected_error_message):
-            psmidx.append(psmidx3)
-
-    def test_argmin(self):
-        pidx = pd.Index([100, 50, 10, 20, 30, 60, 0, 50, 0, 100, 100, 100, 20, 0, 0])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.argmin(), psidx.argmin())
-
-        # MultiIndex
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        with self.assertRaisesRegex(
-            TypeError, "reduction operation 'argmin' not allowed for this dtype"
-        ):
-            psidx.argmin()
-
-    def test_argmax(self):
-        pidx = pd.Index([100, 50, 10, 20, 30, 60, 0, 50, 0, 100, 100, 100, 20, 0, 0])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.argmax(), psidx.argmax())
-
-        # MultiIndex
-        psidx = ps.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2), ("c", "z", 3)])
-        with self.assertRaisesRegex(
-            TypeError, "reduction operation 'argmax' not allowed for this dtype"
-        ):
-            psidx.argmax()
-
-    def test_min(self):
-        pidx = pd.Index([3, 2, 1])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.min(), psidx.min())
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2)])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pmidx.min(), psmidx.min())
-
-        pidx = pd.DatetimeIndex(["2021-02-01", "2021-01-01", "2021-04-01", "2021-03-01"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.min(), psidx.min())
-
-    def test_max(self):
-        pidx = pd.Index([3, 2, 1])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.max(), psidx.max())
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x", 1), ("b", "y", 2)])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pmidx.max(), psmidx.max())
-
-        pidx = pd.DatetimeIndex(["2021-02-01", "2021-01-01", "2021-04-01", "2021-03-01"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.max(), psidx.max())
-
-    def test_monotonic(self):
-        # test monotonic_increasing & monotonic_decreasing for MultiIndex.
-        # Since the Behavior for null value was changed in pandas >= 1.0.0,
-        # several cases are tested differently.
-        datas = []
-
-        # increasing / decreasing ordered each index level with string
-        datas.append([("w", "a"), ("x", "b"), ("y", "c"), ("z", "d")])
-        datas.append([("w", "d"), ("x", "c"), ("y", "b"), ("z", "a")])
-        datas.append([("z", "a"), ("y", "b"), ("x", "c"), ("w", "d")])
-        datas.append([("z", "d"), ("y", "c"), ("x", "b"), ("w", "a")])
-        # mixed order each index level with string
-        datas.append([("z", "a"), ("x", "b"), ("y", "c"), ("w", "d")])
-        datas.append([("z", "a"), ("y", "c"), ("x", "b"), ("w", "d")])
-
-        # increasing / decreasing ordered each index level with integer
-        datas.append([(1, 100), (2, 200), (3, 300), (4, 400), (5, 500)])
-        datas.append([(1, 500), (2, 400), (3, 300), (4, 200), (5, 100)])
-        datas.append([(5, 100), (4, 200), (3, 300), (2, 400), (1, 500)])
-        datas.append([(5, 500), (4, 400), (3, 300), (2, 200), (1, 100)])
-        # mixed order each index level with integer
-        datas.append([(1, 500), (3, 400), (2, 300), (4, 200), (5, 100)])
-        datas.append([(1, 100), (2, 300), (3, 200), (4, 400), (5, 500)])
-
-        # integer / negative mixed tests
-        datas.append([("a", -500), ("b", -400), ("c", -300), ("d", -200), ("e", -100)])
-        datas.append([("e", -500), ("d", -400), ("c", -300), ("b", -200), ("a", -100)])
-        datas.append([(-5, "a"), (-4, "b"), (-3, "c"), (-2, "d"), (-1, "e")])
-        datas.append([(-5, "e"), (-4, "d"), (-3, "c"), (-2, "b"), (-1, "a")])
-        datas.append([(-5, "e"), (-3, "d"), (-2, "c"), (-4, "b"), (-1, "a")])
-        datas.append([(-5, "e"), (-4, "c"), (-3, "b"), (-2, "d"), (-1, "a")])
-
-        # boolean type tests
-        datas.append([(True, True), (True, True)])
-        datas.append([(True, True), (True, False)])
-        datas.append([(True, False), (True, True)])
-        datas.append([(False, True), (False, True)])
-        datas.append([(False, True), (False, False)])
-        datas.append([(False, False), (False, True)])
-        datas.append([(True, True), (False, True)])
-        datas.append([(True, True), (False, False)])
-        datas.append([(True, False), (False, True)])
-        datas.append([(False, True), (True, True)])
-        datas.append([(False, True), (True, False)])
-        datas.append([(False, False), (True, True)])
-
-        # duplicated index value tests
-        datas.append([("x", "d"), ("y", "c"), ("y", "b"), ("z", "a")])
-        datas.append([("x", "d"), ("y", "b"), ("y", "c"), ("z", "a")])
-
-        # more depth tests
-        datas.append([("x", "d", "o"), ("y", "c", "p"), ("y", "c", "q"), ("z", "a", "r")])
-        datas.append([("x", "d", "o"), ("y", "c", "q"), ("y", "c", "p"), ("z", "a", "r")])
-
-        # None type tests (None type is treated as False from pandas >= 1.1.4)
-        # Refer https://github.com/pandas-dev/pandas/issues/37220
-        datas.append([(1, 100), (2, 200), (None, 300), (4, 400), (5, 500)])
-        datas.append([(1, 100), (2, 200), (None, None), (4, 400), (5, 500)])
-        datas.append([("x", "d"), ("y", "c"), ("y", None), ("z", "a")])
-        datas.append([("x", "d"), ("y", "c"), ("y", "b"), (None, "a")])
-        datas.append([("x", "d"), ("y", "b"), ("y", "c"), (None, "a")])
-        datas.append([("x", "d", "o"), ("y", "c", "p"), ("y", "c", None), ("z", "a", "r")])
-
-        for data in datas:
-            with self.subTest(data=data):
-                pmidx = pd.MultiIndex.from_tuples(data)
-                psmidx = ps.from_pandas(pmidx)
-                self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-                self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-        # datas below return different result depends on pandas version.
-        # Because the behavior of handling null values is changed in pandas >= 1.1.4.
-        # Since Koalas follows latest pandas, all of them should return `False`.
-        datas = []
-        datas.append([(1, 100), (2, 200), (3, None), (4, 400), (5, 500)])
-        datas.append([(1, None), (2, 200), (3, 300), (4, 400), (5, 500)])
-        datas.append([(1, 100), (2, 200), (3, 300), (4, 400), (5, None)])
-        datas.append([(False, None), (True, True)])
-        datas.append([(None, False), (True, True)])
-        datas.append([(False, False), (True, None)])
-        datas.append([(False, False), (None, True)])
-        datas.append([("x", "d"), ("y", None), ("y", None), ("z", "a")])
-        datas.append([("x", "d", "o"), ("y", "c", None), ("y", "c", None), ("z", "a", "r")])
-        datas.append([(1, 100), (2, 200), (3, 300), (4, 400), (None, 500)])
-        datas.append([(1, 100), (2, 200), (3, 300), (4, 400), (None, None)])
-        datas.append([(5, 100), (4, 200), (3, None), (2, 400), (1, 500)])
-        datas.append([(5, None), (4, 200), (3, 300), (2, 400), (1, 500)])
-        datas.append([(5, 100), (4, 200), (3, None), (2, 400), (1, 500)])
-        datas.append([(5, 100), (4, 200), (3, 300), (2, 400), (1, None)])
-        datas.append([(True, None), (True, True)])
-        datas.append([(None, True), (True, True)])
-        datas.append([(True, True), (None, True)])
-        datas.append([(True, True), (True, None)])
-        datas.append([(None, 100), (2, 200), (3, 300), (4, 400), (5, 500)])
-        datas.append([(None, None), (2, 200), (3, 300), (4, 400), (5, 500)])
-        datas.append([("x", "d"), ("y", None), ("y", "c"), ("z", "a")])
-        datas.append([("x", "d", "o"), ("y", "c", None), ("y", "c", "q"), ("z", "a", "r")])
-
-        for data in datas:
-            with self.subTest(data=data):
-                pmidx = pd.MultiIndex.from_tuples(data)
-                psmidx = ps.from_pandas(pmidx)
-                if LooseVersion(pd.__version__) < LooseVersion("1.1.4"):
-                    self.assert_eq(psmidx.is_monotonic_increasing, False)
-                    self.assert_eq(psmidx.is_monotonic_decreasing, False)
-                else:
-                    self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-                    self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-        # The datas below are tested another way since they cannot be an arguments for
-        # `MultiIndex.from_tuples` in pandas >= 1.1.0.
-        # Refer https://github.com/databricks/koalas/pull/1688#issuecomment-667156560 for detail.
-        if LooseVersion(pd.__version__) < LooseVersion("1.1.0"):
-            pmidx = pd.MultiIndex.from_tuples(
-                [(-5, None), (-4, None), (-3, None), (-2, None), (-1, None)]
-            )
-            psmidx = ps.from_pandas(pmidx)
-            self.assert_eq(psmidx.is_monotonic_increasing, False)
-            self.assert_eq(psmidx.is_monotonic_decreasing, False)
-
-            pmidx = pd.MultiIndex.from_tuples(
-                [(None, "e"), (None, "c"), (None, "b"), (None, "d"), (None, "a")]
-            )
-            psmidx = ps.from_pandas(pmidx)
-            self.assert_eq(psmidx.is_monotonic_increasing, False)
-            self.assert_eq(psmidx.is_monotonic_decreasing, False)
-
-            pmidx = pd.MultiIndex.from_tuples(
-                [(None, None), (None, None), (None, None), (None, None), (None, None)]
-            )
-            psmidx = ps.from_pandas(pmidx)
-            self.assert_eq(psmidx.is_monotonic_increasing, False)
-            self.assert_eq(psmidx.is_monotonic_decreasing, False)
-
-            pmidx = pd.MultiIndex.from_tuples([(None, None)])
-            psmidx = ps.from_pandas(pmidx)
-            self.assert_eq(psmidx.is_monotonic_increasing, False)
-            self.assert_eq(psmidx.is_monotonic_decreasing, False)
-
-        else:
-            # For [(-5, None), (-4, None), (-3, None), (-2, None), (-1, None)]
-            psdf = ps.DataFrame({"a": [-5, -4, -3, -2, -1], "b": [1, 1, 1, 1, 1]})
-            psdf["b"] = None
-            psmidx = psdf.set_index(["a", "b"]).index
-            pmidx = psmidx._to_pandas()
-            self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-            self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-            # For [(None, "e"), (None, "c"), (None, "b"), (None, "d"), (None, "a")]
-            psdf = ps.DataFrame({"a": [1, 1, 1, 1, 1], "b": ["e", "c", "b", "d", "a"]})
-            psdf["a"] = None
-            psmidx = psdf.set_index(["a", "b"]).index
-            pmidx = psmidx._to_pandas()
-            self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-            self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-            # For [(None, None), (None, None), (None, None), (None, None), (None, None)]
-            psdf = ps.DataFrame({"a": [1, 1, 1, 1, 1], "b": [1, 1, 1, 1, 1]})
-            psdf["a"] = None
-            psdf["b"] = None
-            psmidx = psdf.set_index(["a", "b"]).index
-            pmidx = psmidx._to_pandas()
-            self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-            self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-            # For [(None, None)]
-            psdf = ps.DataFrame({"a": [1], "b": [1]})
-            psdf["a"] = None
-            psdf["b"] = None
-            psmidx = psdf.set_index(["a", "b"]).index
-            pmidx = psmidx._to_pandas()
-            self.assert_eq(psmidx.is_monotonic_increasing, pmidx.is_monotonic_increasing)
-            self.assert_eq(psmidx.is_monotonic_decreasing, pmidx.is_monotonic_decreasing)
-
-    def test_difference(self):
-        # Index
-        pidx1 = pd.Index([1, 2, 3, 4], name="koalas")
-        pidx2 = pd.Index([3, 4, 5, 6], name="koalas")
-        psidx1 = ps.from_pandas(pidx1)
-        psidx2 = ps.from_pandas(pidx2)
-        # Series
-        pser = pd.Series([3, 4, 5, 6], name="koalas")
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(
-            psidx1.difference(psidx2).sort_values(), pidx1.difference(pidx2).sort_values()
-        )
-        self.assert_eq(psidx1.difference(psser).sort_values(), pidx1.difference(pser).sort_values())
-        self.assert_eq(
-            psidx1.difference([3, 4, 5, 6]).sort_values(),
-            pidx1.difference([3, 4, 5, 6]).sort_values(),
-        )
-        self.assert_eq(
-            psidx1.difference((3, 4, 5, 6)).sort_values(),
-            pidx1.difference((3, 4, 5, 6)).sort_values(),
-        )
-        self.assert_eq(
-            psidx1.difference({3, 4, 5, 6}).sort_values(),
-            pidx1.difference({3, 4, 5, 6}).sort_values(),
-        )
-        self.assert_eq(
-            psidx1.difference({3: 1, 4: 2, 5: 3, 6: 4}).sort_values(),
-            pidx1.difference({3: 1, 4: 2, 5: 3, 6: 4}).sort_values(),
-        )
-
-        # Exceptions for Index
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx1.difference("1234")
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx1.difference(1234)
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx1.difference(12.34)
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx1.difference(None)
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx1.difference(np.nan)
-        with self.assertRaisesRegex(
-            ValueError, "The 'sort' keyword only takes the values of None or True; 1 was passed."
-        ):
-            psidx1.difference(psidx2, sort=1)
-
-        # MultiIndex
-        pmidx1 = pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("b", "y", 2), ("c", "z", 3)], names=["hello", "koalas", "world"]
-        )
-        pmidx2 = pd.MultiIndex.from_tuples(
-            [("a", "x", 1), ("b", "z", 2), ("k", "z", 3)], names=["hello", "koalas", "world"]
-        )
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-
-        self.assert_eq(
-            psmidx1.difference(psmidx2).sort_values(), pmidx1.difference(pmidx2).sort_values()
-        )
-        self.assert_eq(
-            psmidx1.difference(psidx1).sort_values(), pmidx1.difference(pidx1).sort_values()
-        )
-        self.assert_eq(
-            psidx1.difference(psmidx1).sort_values(), pidx1.difference(pmidx1).sort_values()
-        )
-        self.assert_eq(psidx1.difference(psser).sort_values(), pidx1.difference(pser).sort_values())
-        self.assert_eq(
-            psmidx1.difference({("a", "x", 1)}).sort_values(),
-            pmidx1.difference({("a", "x", 1)}).sort_values(),
-        )
-        self.assert_eq(
-            psmidx1.difference({("a", "x", 1): [1, 2, 3]}).sort_values(),
-            pmidx1.difference({("a", "x", 1): [1, 2, 3]}).sort_values(),
-        )
-
-        # Exceptions for MultiIndex
-        with self.assertRaisesRegex(TypeError, "other must be a MultiIndex or a list of tuples"):
-            psmidx1.difference(["b", "z", "2"])
-
-    def test_repeat(self):
-        pidx = pd.Index(["a", "b", "c"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.repeat(3).sort_values(), pidx.repeat(3).sort_values())
-        self.assert_eq(psidx.repeat(0).sort_values(), pidx.repeat(0).sort_values())
-        self.assert_eq((psidx + "x").repeat(3).sort_values(), (pidx + "x").repeat(3).sort_values())
-
-        self.assertRaises(ValueError, lambda: psidx.repeat(-1))
-        self.assertRaises(TypeError, lambda: psidx.repeat("abc"))
-
-        pmidx = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("y", "c")])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(psmidx.repeat(3).sort_values(), pmidx.repeat(3).sort_values())
-        self.assert_eq(psmidx.repeat(0).sort_values(), pmidx.repeat(0).sort_values(), almost=True)
-
-        self.assertRaises(ValueError, lambda: psmidx.repeat(-1))
-        self.assertRaises(TypeError, lambda: psmidx.repeat("abc"))
-
-    def test_unique(self):
-        pidx = pd.Index(["a", "b", "a"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.unique().sort_values(), pidx.unique().sort_values())
-        self.assert_eq(psidx.unique().sort_values(), pidx.unique().sort_values())
-
-        pmidx = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("x", "a")])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(psmidx.unique().sort_values(), pmidx.unique().sort_values())
-        self.assert_eq(psmidx.unique().sort_values(), pmidx.unique().sort_values())
-
-        with self.assertRaisesRegex(
-            IndexError, "Too many levels: Index has only 1 level, -2 is not a valid level number"
-        ):
-            psidx.unique(level=-2)
-
-    def test_asof(self):
-        # Increasing values
-        pidx = pd.Index(["2013-12-31", "2014-01-02", "2014-01-03"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.asof("2014-01-01"), pidx.asof("2014-01-01"))
-        self.assert_eq(psidx.asof("2014-01-02"), pidx.asof("2014-01-02"))
-        self.assert_eq(repr(psidx.asof("1999-01-02")), repr(pidx.asof("1999-01-02")))
-        self.assert_eq(psidx.asof("2014-01-04"), pidx.asof("2014-01-04"))
-
-        pidx = pd.DatetimeIndex(["2013-12-31", "2014-01-02", "2014-01-03"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.asof("2014-01-01"), pidx.asof("2014-01-01"))
-        self.assert_eq(psidx.asof("2014-01-02"), pidx.asof("2014-01-02"))
-        self.assert_eq(repr(psidx.asof("1999-01-02")), repr(pidx.asof("1999-01-02")))
-
-        # Decreasing values
-        pidx = pd.Index(["2014-01-03", "2014-01-02", "2013-12-31"])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.asof("2014-01-01"), pidx.asof("2014-01-01"))
-        self.assert_eq(psidx.asof("2014-01-02"), pidx.asof("2014-01-02"))
-        self.assert_eq(psidx.asof("1999-01-02"), pidx.asof("1999-01-02"))
-        self.assert_eq(repr(psidx.asof("2015-01-02")), repr(pidx.asof("2015-01-02")))
-
-        pidx = pd.DatetimeIndex(["2014-01-03", "2014-01-02", "2013-12-31"])
-        psidx = ps.from_pandas(pidx)
-
-        # TODO: a pandas bug?
-        # self.assert_eq(psidx.asof("2014-01-01"), pidx.asof("2014-01-01"))
-        # self.assert_eq(psidx.asof("2014-01-02"), pidx.asof("2014-01-02"))
-        # self.assert_eq(psidx.asof("1999-01-02"), pidx.asof("1999-01-02"))
-        # self.assert_eq(repr(psidx.asof("2015-01-02")), repr(pidx.asof("2015-01-02")))
-        self.assert_eq(psidx.asof("2014-01-01"), pd.Timestamp("2014-01-02 00:00:00"))
-        self.assert_eq(psidx.asof("2014-01-02"), pd.Timestamp("2014-01-02 00:00:00"))
-        self.assert_eq(psidx.asof("1999-01-02"), pd.Timestamp("2013-12-31 00:00:00"))
-        self.assert_eq(repr(psidx.asof("2015-01-02")), repr(pd.NaT))
-
-        # Not increasing, neither decreasing (ValueError)
-        psidx = ps.Index(["2013-12-31", "2015-01-02", "2014-01-03"])
-        self.assertRaises(ValueError, lambda: psidx.asof("2013-12-31"))
-
-        psmidx = ps.MultiIndex.from_tuples([("a", "a"), ("a", "b"), ("a", "c")])
-        self.assertRaises(NotImplementedError, lambda: psmidx.asof(("a", "b")))
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43608): Enable IndexesTests.test_union for pandas 2.0.0.",
-    )
-    def test_union(self):
-        # Index
-        pidx1 = pd.Index([1, 2, 3, 4])
-        pidx2 = pd.Index([3, 4, 5, 6])
-        pidx3 = pd.Index([7.0, 8.0, 9.0, 10.0])
-        psidx1 = ps.from_pandas(pidx1)
-        psidx2 = ps.from_pandas(pidx2)
-        psidx3 = ps.from_pandas(pidx3)
-
-        self.assert_eq(psidx1.union(psidx2), pidx1.union(pidx2))
-        self.assert_eq(psidx2.union(psidx1), pidx2.union(pidx1))
-        self.assert_eq(psidx1.union(psidx3), pidx1.union(pidx3))
-        # Deprecated case, but adding to track if pandas stop supporting union
-        # as a set operation. It should work fine until stop supporting anyway.
-        # No longer supported from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(psidx1 | psidx2, ps.Index([3, 4], dtype="int64"))
-        else:
-            self.assert_eq(pidx1 | pidx2, psidx1 | psidx2)
-
-        self.assert_eq(psidx1.union([3, 4, 5, 6]), pidx1.union([3, 4, 5, 6]), almost=True)
-        self.assert_eq(psidx2.union([1, 2, 3, 4]), pidx2.union([1, 2, 3, 4]), almost=True)
-        self.assert_eq(
-            psidx1.union(ps.Series([3, 4, 5, 6])), pidx1.union(pd.Series([3, 4, 5, 6])), almost=True
-        )
-        self.assert_eq(
-            psidx2.union(ps.Series([1, 2, 3, 4])), pidx2.union(pd.Series([1, 2, 3, 4])), almost=True
-        )
-
-        # Testing if the result is correct after sort=False.
-        self.assert_eq(
-            psidx1.union(psidx2, sort=False).sort_values(),
-            pidx1.union(pidx2, sort=False).sort_values(),
-        )
-        self.assert_eq(
-            psidx2.union(psidx1, sort=False).sort_values(),
-            pidx2.union(pidx1, sort=False).sort_values(),
-        )
-        self.assert_eq(
-            psidx1.union([3, 4, 5, 6], sort=False).sort_values(),
-            pidx1.union([3, 4, 5, 6], sort=False).sort_values(),
-            almost=True,
-        )
-        self.assert_eq(
-            psidx2.union([1, 2, 3, 4], sort=False).sort_values(),
-            pidx2.union([1, 2, 3, 4], sort=False).sort_values(),
-            almost=True,
-        )
-        self.assert_eq(
-            psidx1.union(ps.Series([3, 4, 5, 6]), sort=False).sort_values(),
-            pidx1.union(pd.Series([3, 4, 5, 6]), sort=False).sort_values(),
-            almost=True,
-        )
-        self.assert_eq(
-            psidx2.union(ps.Series([1, 2, 3, 4]), sort=False).sort_values(),
-            pidx2.union(pd.Series([1, 2, 3, 4]), sort=False).sort_values(),
-            almost=True,
-        )
-
-        pidx1 = pd.Index([1, 2, 3, 4, 3, 4, 3, 4])
-        pidx2 = pd.Index([3, 4, 3, 4, 5, 6])
-        psidx1 = ps.from_pandas(pidx1)
-        psidx2 = ps.from_pandas(pidx2)
-
-        self.assert_eq(psidx1.union(psidx2), pidx1.union(pidx2))
-        self.assert_eq(
-            psidx1.union([3, 4, 3, 3, 5, 6]), pidx1.union([3, 4, 3, 4, 5, 6]), almost=True
-        )
-        self.assert_eq(
-            psidx1.union(ps.Series([3, 4, 3, 3, 5, 6])),
-            pidx1.union(pd.Series([3, 4, 3, 4, 5, 6])),
-            almost=True,
-        )
-
-        # Manually create the expected result here since there is a bug in Index.union
-        # dropping duplicated values in pandas < 1.3.
-        expected = pd.Index([1, 2, 3, 3, 3, 4, 4, 4, 5, 6])
-        self.assert_eq(psidx2.union(psidx1), expected)
-        self.assert_eq(
-            psidx2.union([1, 2, 3, 4, 3, 4, 3, 4]),
-            expected,
-            almost=True,
-        )
-        self.assert_eq(
-            psidx2.union(ps.Series([1, 2, 3, 4, 3, 4, 3, 4])),
-            expected,
-            almost=True,
-        )
-
-        # MultiIndex
-        pmidx1 = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("x", "a"), ("x", "b")])
-        pmidx2 = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("x", "c"), ("x", "d")])
-        pmidx3 = pd.MultiIndex.from_tuples([(1, 1), (1, 2), (1, 3), (1, 4), (1, 3), (1, 4)])
-        pmidx4 = pd.MultiIndex.from_tuples([(1, 3), (1, 4), (1, 5), (1, 6)])
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-        psmidx3 = ps.from_pandas(pmidx3)
-        psmidx4 = ps.from_pandas(pmidx4)
-
-        # Manually create the expected result here since there is a bug in MultiIndex.union
-        # dropping duplicated values in pandas < 1.3.
-        expected = pd.MultiIndex.from_tuples(
-            [("x", "a"), ("x", "a"), ("x", "b"), ("x", "b"), ("x", "c"), ("x", "d")]
-        )
-        self.assert_eq(psmidx1.union(psmidx2), expected)
-        self.assert_eq(psmidx2.union(psmidx1), expected)
-        self.assert_eq(
-            psmidx1.union([("x", "a"), ("x", "b"), ("x", "c"), ("x", "d")]),
-            expected,
-        )
-        self.assert_eq(
-            psmidx2.union([("x", "a"), ("x", "b"), ("x", "a"), ("x", "b")]),
-            expected,
-        )
-
-        expected = pd.MultiIndex.from_tuples(
-            [(1, 1), (1, 2), (1, 3), (1, 3), (1, 4), (1, 4), (1, 5), (1, 6)]
-        )
-        self.assert_eq(psmidx3.union(psmidx4), expected)
-        self.assert_eq(psmidx4.union(psmidx3), expected)
-        self.assert_eq(
-            psmidx3.union([(1, 3), (1, 4), (1, 5), (1, 6)]),
-            expected,
-        )
-        self.assert_eq(
-            psmidx4.union([(1, 1), (1, 2), (1, 3), (1, 4), (1, 3), (1, 4)]),
-            expected,
-        )
-
-        # Testing if the result is correct after sort=False.
-        # Manually create the expected result here since there is a bug in MultiIndex.union
-        # dropping duplicated values in pandas < 1.3.
-        expected = pd.MultiIndex.from_tuples(
-            [("x", "a"), ("x", "a"), ("x", "b"), ("x", "b"), ("x", "c"), ("x", "d")]
-        )
-        self.assert_eq(psmidx1.union(psmidx2, sort=False).sort_values(), expected)
-        self.assert_eq(psmidx2.union(psmidx1, sort=False).sort_values(), expected)
-        self.assert_eq(
-            psmidx1.union(
-                [("x", "a"), ("x", "b"), ("x", "c"), ("x", "d")], sort=False
-            ).sort_values(),
-            expected,
-        )
-        self.assert_eq(
-            psmidx2.union(
-                [("x", "a"), ("x", "b"), ("x", "a"), ("x", "b")], sort=False
-            ).sort_values(),
-            expected,
-        )
-
-        expected = pd.MultiIndex.from_tuples(
-            [(1, 1), (1, 2), (1, 3), (1, 3), (1, 4), (1, 4), (1, 5), (1, 6)]
-        )
-        self.assert_eq(psmidx3.union(psmidx4, sort=False).sort_values(), expected)
-        self.assert_eq(psmidx4.union(psmidx3, sort=False).sort_values(), expected)
-        self.assert_eq(
-            psmidx3.union([(1, 3), (1, 4), (1, 5), (1, 6)], sort=False).sort_values(), expected
-        )
-        self.assert_eq(
-            psmidx4.union(
-                [(1, 1), (1, 2), (1, 3), (1, 4), (1, 3), (1, 4)], sort=False
-            ).sort_values(),
-            expected,
-        )
-
-        self.assertRaises(NotImplementedError, lambda: psidx1.union(psmidx1))
-        self.assertRaises(TypeError, lambda: psmidx1.union(psidx1))
-        self.assertRaises(TypeError, lambda: psmidx1.union(["x", "a"]))
-        self.assertRaises(ValueError, lambda: psidx1.union(ps.range(2)))
-
-    def test_take(self):
-        # Index
-        pidx = pd.Index([100, 200, 300, 400, 500], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx.take([0, 2, 4]).sort_values(), pidx.take([0, 2, 4]).sort_values())
-        self.assert_eq(
-            psidx.take(range(0, 5, 2)).sort_values(), pidx.take(range(0, 5, 2)).sort_values()
-        )
-        self.assert_eq(psidx.take([-4, -2, 0]).sort_values(), pidx.take([-4, -2, 0]).sort_values())
-        self.assert_eq(
-            psidx.take(range(-4, 1, 2)).sort_values(), pidx.take(range(-4, 1, 2)).sort_values()
-        )
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples(
-            [("x", "a"), ("x", "b"), ("x", "c")], names=["hello", "Koalas"]
-        )
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(psmidx.take([0, 2]).sort_values(), pmidx.take([0, 2]).sort_values())
-        self.assert_eq(
-            psmidx.take(range(0, 4, 2)).sort_values(), pmidx.take(range(0, 4, 2)).sort_values()
-        )
-        self.assert_eq(psmidx.take([-2, 0]).sort_values(), pmidx.take([-2, 0]).sort_values())
-        self.assert_eq(
-            psmidx.take(range(-2, 1, 2)).sort_values(), pmidx.take(range(-2, 1, 2)).sort_values()
-        )
-
-        # Checking the type of indices.
-        self.assertRaises(TypeError, lambda: psidx.take(1))
-        self.assertRaises(TypeError, lambda: psidx.take("1"))
-        self.assertRaises(TypeError, lambda: psidx.take({1, 2}))
-        self.assertRaises(TypeError, lambda: psidx.take({1: None, 2: None}))
-        self.assertRaises(TypeError, lambda: psmidx.take(1))
-        self.assertRaises(TypeError, lambda: psmidx.take("1"))
-        self.assertRaises(TypeError, lambda: psmidx.take({1, 2}))
-        self.assertRaises(TypeError, lambda: psmidx.take({1: None, 2: None}))
-
-    def test_index_get_level_values(self):
-        pidx = pd.Index([1, 2, 3], name="ks")
-        psidx = ps.from_pandas(pidx)
-
-        for level in [0, "ks"]:
-            self.assert_eq(psidx.get_level_values(level), pidx.get_level_values(level))
-
-    def test_multiindex_get_level_values(self):
-        pmidx = pd.MultiIndex.from_tuples([("a", "d"), ("b", "e"), ("c", "f")])
-        pmidx.names = ["level_1", "level_2"]
-        psmidx = ps.from_pandas(pmidx)
-
-        for level in [0, 1, "level_1", "level_2"]:
-            self.assert_eq(psmidx.get_level_values(level), pmidx.get_level_values(level))
-
-    def test_index_get_level_number(self):
-        # name of two levels are the same, which is None
-        psdf = ps.DataFrame({"a": [1, 2, 3]}, index=[list("aac"), list("ddf")])
-        with self.assertRaisesRegex(
-            ValueError, "The name None occurs multiple times, use a level number"
-        ):
-            psdf.index._get_level_number(None)
-
-        mi = pd.MultiIndex.from_arrays((list("abc"), list("def")))
-        mi.names = ["level_1", "level_2"]
-        psdf = ps.DataFrame({"a": [1, 2, 3]}, index=mi)
-
-        # level is not int and not in the level name list
-        with self.assertRaisesRegex(KeyError, "Level lv_3 not found"):
-            psdf.index._get_level_number("lv_3")
-
-        # level is int, but an invalid negative number
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index has only"):
-            psdf.index._get_level_number(-3)
-
-        # level is int, but an invalid positive number
-        with self.assertRaisesRegex(IndexError, "Too many levels: Index has only"):
-            psdf.index._get_level_number(3)
-
-        # Correct and valid inputs in numbers
-        level_number = [-2, -1, 0, 1]
-        outputs = [0, 1, 0, 1]
-
-        for lv, output in zip(level_number, outputs):
-            self.assertEqual(output, psdf.index._get_level_number(lv))
-
-        # Valid inputs as level names
-        level_names = ["level_1", "level_2"]
-        outputs = [0, 1]
-
-        for lv, output in zip(level_names, outputs):
-            self.assertEqual(output, psdf.index._get_level_number(lv))
-
-    def test_holds_integer(self):
-        pidx = pd.Index([1, 2, 3, 4])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.holds_integer(), psidx.holds_integer())
-
-        pidx = pd.Index([1.1, 2.2, 3.3, 4.4])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.holds_integer(), psidx.holds_integer())
-
-        pidx = pd.Index(["A", "B", "C", "D"])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.holds_integer(), psidx.holds_integer())
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("y", "a")])
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(pmidx.holds_integer(), psmidx.holds_integer())
-
-        pmidx = pd.MultiIndex.from_tuples([(10, 1), (10, 2), (20, 1)])
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(pmidx.holds_integer(), psmidx.holds_integer())
-
-    def test_abs(self):
-        pidx = pd.Index([-2, -1, 0, 1])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(abs(pidx), abs(psidx))
-        self.assert_eq(np.abs(pidx), np.abs(psidx))
-
-        psidx = ps.MultiIndex.from_tuples([(1, 2)], names=["level1", "level2"])
-        with self.assertRaisesRegex(TypeError, "perform __abs__ with this index"):
-            abs(psidx)
-
-    def test_hasnans(self):
-        # BooleanType
-        pidx = pd.Index([True, False, True, True])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.hasnans, psidx.hasnans)
-
-        pidx = pd.Index([True, False, np.nan, True])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.hasnans, psidx.hasnans)
-
-        # TimestampType
-        pser = pd.Series([pd.Timestamp("2020-07-30") for _ in range(3)])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.hasnans, psser.hasnans)
-
-        pser = pd.Series([pd.Timestamp("2020-07-30"), np.nan, pd.Timestamp("2020-07-30")])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.hasnans, psser.hasnans)
-
-        # empty
-        pidx = pd.Index([])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.hasnans, psidx.hasnans)
-
-        # Not supported for MultiIndex
-        psmidx = ps.Index([("a", 1), ("b", 2)])
-        self.assertRaises(NotImplementedError, lambda: psmidx.hasnans())
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43607): Enable IndexesTests.test_intersection for pandas 2.0.0.",
-    )
-    def test_intersection(self):
-        pidx = pd.Index([1, 2, 3, 4], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-
-        # other = Index
-        pidx_other = pd.Index([3, 4, 5, 6], name="Koalas")
-        psidx_other = ps.from_pandas(pidx_other)
-        self.assert_eq(pidx.intersection(pidx_other), psidx.intersection(psidx_other).sort_values())
-        self.assert_eq(
-            (pidx + 1).intersection(pidx_other), (psidx + 1).intersection(psidx_other).sort_values()
-        )
-        # Deprecated case, but adding to track if pandas stop supporting intersection
-        # as a set operation. It should work fine until stop supporting anyway.
-        # No longer supported from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                (psidx & psidx_other).sort_values(), ps.Index([3, 1, 7, 1], dtype="int64")
-            )
-        else:
-            self.assert_eq(pidx & pidx_other, (psidx & psidx_other).sort_values())
-
-        pidx_other_different_name = pd.Index([3, 4, 5, 6], name="Databricks")
-        psidx_other_different_name = ps.from_pandas(pidx_other_different_name)
-        self.assert_eq(
-            pidx.intersection(pidx_other_different_name),
-            psidx.intersection(psidx_other_different_name).sort_values(),
-        )
-        self.assert_eq(
-            (pidx + 1).intersection(pidx_other_different_name),
-            (psidx + 1).intersection(psidx_other_different_name).sort_values(),
-        )
-
-        pidx_other_from_frame = pd.DataFrame({"a": [3, 4, 5, 6]}).set_index("a").index
-        psidx_other_from_frame = ps.from_pandas(pidx_other_from_frame)
-        self.assert_eq(
-            pidx.intersection(pidx_other_from_frame),
-            psidx.intersection(psidx_other_from_frame).sort_values(),
-        )
-        self.assert_eq(
-            (pidx + 1).intersection(pidx_other_from_frame),
-            (psidx + 1).intersection(psidx_other_from_frame).sort_values(),
-        )
-
-        # other = MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        psmidx = ps.from_pandas(pmidx)
-        if LooseVersion(pd.__version__) < LooseVersion("1.2.0"):
-            self.assert_eq(
-                psidx.intersection(psmidx).sort_values(),
-                psidx._psdf.head(0).index.rename(None),
-                almost=True,
-            )
-            self.assert_eq(
-                (psidx + 1).intersection(psmidx).sort_values(),
-                psidx._psdf.head(0).index.rename(None),
-                almost=True,
-            )
-        else:
-            self.assert_eq(
-                pidx.intersection(pmidx), psidx.intersection(psmidx).sort_values(), almost=True
-            )
-            self.assert_eq(
-                (pidx + 1).intersection(pmidx),
-                (psidx + 1).intersection(psmidx).sort_values(),
-                almost=True,
-            )
-
-        # other = Series
-        pser = pd.Series([3, 4, 5, 6])
-        psser = ps.from_pandas(pser)
-        if LooseVersion(pd.__version__) < LooseVersion("1.2.0"):
-            self.assert_eq(psidx.intersection(psser).sort_values(), ps.Index([3, 4], name="Koalas"))
-            self.assert_eq(
-                (psidx + 1).intersection(psser).sort_values(), ps.Index([3, 4, 5], name="Koalas")
-            )
-        else:
-            self.assert_eq(pidx.intersection(pser), psidx.intersection(psser).sort_values())
-            self.assert_eq(
-                (pidx + 1).intersection(pser), (psidx + 1).intersection(psser).sort_values()
-            )
-
-        pser_different_name = pd.Series([3, 4, 5, 6], name="Databricks")
-        psser_different_name = ps.from_pandas(pser_different_name)
-        if LooseVersion(pd.__version__) < LooseVersion("1.2.0"):
-            self.assert_eq(
-                psidx.intersection(psser_different_name).sort_values(),
-                ps.Index([3, 4], name="Koalas"),
-            )
-            self.assert_eq(
-                (psidx + 1).intersection(psser_different_name).sort_values(),
-                ps.Index([3, 4, 5], name="Koalas"),
-            )
-        else:
-            self.assert_eq(
-                pidx.intersection(pser_different_name),
-                psidx.intersection(psser_different_name).sort_values(),
-            )
-            self.assert_eq(
-                (pidx + 1).intersection(pser_different_name),
-                (psidx + 1).intersection(psser_different_name).sort_values(),
-            )
-
-        others = ([3, 4, 5, 6], (3, 4, 5, 6), {3: None, 4: None, 5: None, 6: None})
-        for other in others:
-            if LooseVersion(pd.__version__) < LooseVersion("1.2.0"):
-                self.assert_eq(
-                    psidx.intersection(other).sort_values(), ps.Index([3, 4], name="Koalas")
-                )
-                self.assert_eq(
-                    (psidx + 1).intersection(other).sort_values(),
-                    ps.Index([3, 4, 5], name="Koalas"),
-                )
-            else:
-                self.assert_eq(pidx.intersection(other), psidx.intersection(other).sort_values())
-                self.assert_eq(
-                    (pidx + 1).intersection(other), (psidx + 1).intersection(other).sort_values()
-                )
-
-        # MultiIndex / other = Index
-        self.assert_eq(
-            pmidx.intersection(pidx), psmidx.intersection(psidx).sort_values(), almost=True
-        )
-        self.assert_eq(
-            pmidx.intersection(pidx_other_from_frame),
-            psmidx.intersection(psidx_other_from_frame).sort_values(),
-            almost=True,
-        )
-
-        # MultiIndex / other = MultiIndex
-        pmidx_other = pd.MultiIndex.from_tuples([("c", "z"), ("d", "w")])
-        psmidx_other = ps.from_pandas(pmidx_other)
-        self.assert_eq(
-            pmidx.intersection(pmidx_other), psmidx.intersection(psmidx_other).sort_values()
-        )
-
-        # MultiIndex / other = list
-        other = [("c", "z"), ("d", "w")]
-        self.assert_eq(pmidx.intersection(other), psmidx.intersection(other).sort_values())
-
-        # MultiIndex / other = tuple
-        other = (("c", "z"), ("d", "w"))
-        self.assert_eq(pmidx.intersection(other), psmidx.intersection(other).sort_values())
-
-        # MultiIndex / other = dict
-        other = {("c", "z"): None, ("d", "w"): None}
-        self.assert_eq(pmidx.intersection(other), psmidx.intersection(other).sort_values())
-
-        # MultiIndex with different names.
-        pmidx1 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")], names=["X", "Y"])
-        pmidx2 = pd.MultiIndex.from_tuples([("c", "z"), ("d", "w")], names=["A", "B"])
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.intersection(pmidx2), psmidx1.intersection(psmidx2).sort_values())
-
-        with self.assertRaisesRegex(TypeError, "Input must be Index or array-like"):
-            psidx.intersection(4)
-        with self.assertRaisesRegex(TypeError, "other must be a MultiIndex or a list of tuples"):
-            psmidx.intersection(4)
-        with self.assertRaisesRegex(TypeError, "other must be a MultiIndex or a list of tuples"):
-            psmidx.intersection(ps.Series([3, 4, 5, 6]))
-        with self.assertRaisesRegex(TypeError, "other must be a MultiIndex or a list of tuples"):
-            psmidx.intersection([("c", "z"), ["d", "w"]])
-        with self.assertRaisesRegex(ValueError, "Index data must be 1-dimensional"):
-            psidx.intersection(ps.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}))
-        with self.assertRaisesRegex(ValueError, "Index data must be 1-dimensional"):
-            psmidx.intersection(ps.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}))
-        # other = list of tuple
-        with self.assertRaisesRegex(ValueError, "Names should be list-like for a MultiIndex"):
-            psidx.intersection([(1, 2), (3, 4)])
-
-    def test_item(self):
-        pidx = pd.Index([10])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.item(), psidx.item())
-
-        # with timestamp
-        pidx = pd.Index([datetime(1990, 3, 9)])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.item(), psidx.item())
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x")])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pmidx.item(), psmidx.item())
-
-        # MultiIndex with timestamp
-        pmidx = pd.MultiIndex.from_tuples([(datetime(1990, 3, 9), datetime(2019, 8, 15))])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pidx.item(), psidx.item())
-
-        err_msg = "can only convert an array of size 1 to a Python scalar"
-        with self.assertRaisesRegex(ValueError, err_msg):
-            ps.Index([10, 20]).item()
-        with self.assertRaisesRegex(ValueError, err_msg):
-            ps.MultiIndex.from_tuples([("a", "x"), ("b", "y")]).item()
-
-    def test_inferred_type(self):
-        # Integer
-        pidx = pd.Index([1, 2, 3])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.inferred_type, psidx.inferred_type)
-
-        # Floating
-        pidx = pd.Index([1.0, 2.0, 3.0])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.inferred_type, psidx.inferred_type)
-
-        # String
-        pidx = pd.Index(["a", "b", "c"])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.inferred_type, psidx.inferred_type)
-
-        # Boolean
-        pidx = pd.Index([True, False, True, False])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.inferred_type, psidx.inferred_type)
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x")])
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(pmidx.inferred_type, psmidx.inferred_type)
-
-    def test_multi_index_from_index(self):
-        tuples = [(1, "red"), (1, "blue"), (2, "red"), (2, "blue")]
-        pmidx = pd.Index(tuples)
-        psmidx = ps.Index(tuples)
-
-        self.assertTrue(isinstance(psmidx, ps.MultiIndex))
-        self.assert_eq(pmidx, psmidx)
-
-        # Specify the `names`
-        # Specify the `names` while Index creating is no longer supported from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            pmidx = pd.Index(tuples)
-            pmidx.names = ["Hello", "Koalas"]
-            psmidx = ps.Index(tuples)
-            psmidx.names = ["Hello", "Koalas"]
-        else:
-            pmidx = pd.Index(tuples, names=["Hello", "Koalas"])
-            psmidx = ps.Index(tuples, names=["Hello", "Koalas"])
-
-        self.assertTrue(isinstance(psmidx, ps.MultiIndex))
-        self.assert_eq(pmidx, psmidx)
-
-    def test_multiindex_from_frame(self):
-        pdf = pd.DataFrame(
-            [["HI", "Temp"], ["HI", "Precip"], ["NJ", "Temp"], ["NJ", "Precip"]], columns=["a", "b"]
-        )
-        psdf = ps.from_pandas(pdf)
-        pidx = pd.MultiIndex.from_frame(pdf)
-        psidx = ps.MultiIndex.from_frame(psdf)
-
-        self.assert_eq(pidx, psidx)
-
-        # Specify `names`
-        pidx = pd.MultiIndex.from_frame(pdf, names=["state", "observation"])
-        psidx = ps.MultiIndex.from_frame(psdf, names=["state", "observation"])
-        self.assert_eq(pidx, psidx)
-
-        pidx = pd.MultiIndex.from_frame(pdf, names=("state", "observation"))
-        psidx = ps.MultiIndex.from_frame(psdf, names=("state", "observation"))
-        self.assert_eq(pidx, psidx)
-
-        # MultiIndex columns
-        pidx = pd.MultiIndex.from_tuples([("a", "w"), ("b", "x")])
-        pdf.columns = pidx
-        psdf = ps.from_pandas(pdf)
-
-        pidx = pd.MultiIndex.from_frame(pdf)
-        psidx = ps.MultiIndex.from_frame(psdf)
-
-        self.assert_eq(pidx, psidx)
-
-        # tuples for names
-        pidx = pd.MultiIndex.from_frame(pdf, names=[("a", "w"), ("b", "x")])
-        psidx = ps.MultiIndex.from_frame(psdf, names=[("a", "w"), ("b", "x")])
-
-        self.assert_eq(pidx, psidx)
-
-        err_msg = "Input must be a DataFrame"
-        with self.assertRaisesRegex(TypeError, err_msg):
-            ps.MultiIndex.from_frame({"a": [1, 2, 3], "b": [4, 5, 6]})
-
-        self.assertRaises(TypeError, lambda: ps.MultiIndex.from_frame(psdf, names="ab"))
-
-        # non-string names
-        self.assert_eq(
-            ps.MultiIndex.from_frame(psdf, names=[0, 1]),
-            pd.MultiIndex.from_frame(pdf, names=[0, 1]),
-        )
-        self.assert_eq(
-            ps.MultiIndex.from_frame(psdf, names=[("x", 0), ("y", 1)]),
-            pd.MultiIndex.from_frame(pdf, names=[("x", 0), ("y", 1)]),
-        )
-
-        pdf = pd.DataFrame([["HI", "Temp"], ["HI", "Precip"], ["NJ", "Temp"], ["NJ", "Precip"]])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(ps.MultiIndex.from_frame(psdf), pd.MultiIndex.from_frame(pdf))
-
-    def test_is_type_compatible(self):
-        data_types = ["integer", "floating", "string", "boolean"]
-        # Integer
-        pidx = pd.Index([1, 2, 3])
-        psidx = ps.from_pandas(pidx)
-        # is_type_compatible is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            expected_results = [True, False, False, False]
-            for data_type, expected_result in zip(data_types, expected_results):
-                self.assert_eq(psidx.is_type_compatible(data_type), expected_result)
-        else:
-            for data_type in data_types:
-                self.assert_eq(
-                    pidx.is_type_compatible(data_type), psidx.is_type_compatible(data_type)
-                )
-
-        # Floating
-        pidx = pd.Index([1.0, 2.0, 3.0])
-        psidx = ps.from_pandas(pidx)
-        # is_type_compatible is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            expected_results = [False, True, False, False]
-            for data_type, expected_result in zip(data_types, expected_results):
-                self.assert_eq(psidx.is_type_compatible(data_type), expected_result)
-        else:
-            for data_type in data_types:
-                self.assert_eq(
-                    pidx.is_type_compatible(data_type), psidx.is_type_compatible(data_type)
-                )
-
-        # String
-        pidx = pd.Index(["a", "b", "c"])
-        psidx = ps.from_pandas(pidx)
-        # is_type_compatible is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            expected_results = [False, False, True, False]
-            for data_type, expected_result in zip(data_types, expected_results):
-                self.assert_eq(psidx.is_type_compatible(data_type), expected_result)
-        else:
-            for data_type in data_types:
-                self.assert_eq(
-                    pidx.is_type_compatible(data_type), psidx.is_type_compatible(data_type)
-                )
-
-        # Boolean
-        pidx = pd.Index([True, False, True, False])
-        psidx = ps.from_pandas(pidx)
-        # is_type_compatible is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            expected_results = [False, False, False, True]
-            for data_type, expected_result in zip(data_types, expected_results):
-                self.assert_eq(psidx.is_type_compatible(data_type), expected_result)
-        else:
-            for data_type in data_types:
-                self.assert_eq(
-                    pidx.is_type_compatible(data_type), psidx.is_type_compatible(data_type)
-                )
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x")])
-        psmidx = ps.from_pandas(pmidx)
-        # is_type_compatible is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            expected_results = [False, False, False, False]
-            for data_type, expected_result in zip(data_types, expected_results):
-                self.assert_eq(psmidx.is_type_compatible(data_type), expected_result)
-        else:
-            for data_type in data_types:
-                self.assert_eq(
-                    pmidx.is_type_compatible(data_type), psmidx.is_type_compatible(data_type)
-                )
-
-    def test_asi8(self):
-        # Integer
-        pidx = pd.Index([1, 2, 3])
-        psidx = ps.from_pandas(pidx)
-        # asi8 is removed from pandas 2.0.0.
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(np.array(pidx), psidx.asi8)
-            self.assert_eq(np.array(pidx.astype("int")), psidx.astype("int").asi8)
-            self.assert_eq(np.array(pidx.astype("int16")), psidx.astype("int16").asi8)
-            self.assert_eq(np.array(pidx.astype("int8")), psidx.astype("int8").asi8)
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-            self.assert_eq(pidx.astype("int").asi8, psidx.astype("int").asi8)
-            self.assert_eq(pidx.astype("int16").asi8, psidx.astype("int16").asi8)
-            self.assert_eq(pidx.astype("int8").asi8, psidx.astype("int8").asi8)
-
-        # Integer with missing value
-        pidx = pd.Index([1, 2, None, 4, 5])
-        psidx = ps.from_pandas(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(None, psidx.asi8)
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-
-        # Datetime
-        pidx = pd.date_range(end="1/1/2018", periods=3)
-        psidx = ps.from_pandas(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(
-                np.array([1514592000000000000, 1514678400000000000, 1514764800000000000]),
-                psidx.asi8,
-            )
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-
-        # Floating
-        pidx = pd.Index([1.0, 2.0, 3.0])
-        psidx = ps.from_pandas(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(None, psidx.asi8)
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-
-        # String
-        pidx = pd.Index(["a", "b", "c"])
-        psidx = ps.from_pandas(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(None, psidx.asi8)
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-
-        # Boolean
-        pidx = pd.Index([True, False, True, False])
-        psidx = ps.from_pandas(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(None, psidx.asi8)
-        else:
-            self.assert_eq(pidx.asi8, psidx.asi8)
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([(1, 2)])
-        psmidx = ps.from_pandas(pmidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("2.0.0"):
-            self.assert_eq(None, psmidx.asi8)
-        else:
-            self.assert_eq(pmidx.asi8, psmidx.asi8)
-
-    def test_index_is_unique(self):
-        indexes = [("a", "b", "c"), ("a", "a", "c"), (1, 3, 3), (1, 2, 3)]
-        names = [None, "ks", "ks", None]
-        is_uniq = [True, False, False, True]
-
-        for idx, name, expected in zip(indexes, names, is_uniq):
-            pdf = pd.DataFrame({"a": [1, 2, 3]}, index=pd.Index(idx, name=name))
-            psdf = ps.from_pandas(pdf)
-
-            self.assertEqual(psdf.index.is_unique, expected)
-
-    def test_multiindex_is_unique(self):
-        indexes = [
-            [list("abc"), list("edf")],
-            [list("aac"), list("edf")],
-            [list("aac"), list("eef")],
-            [[1, 4, 4], [4, 6, 6]],
-        ]
-        is_uniq = [True, True, False, False]
-
-        for idx, expected in zip(indexes, is_uniq):
-            pdf = pd.DataFrame({"a": [1, 2, 3]}, index=idx)
-            psdf = ps.from_pandas(pdf)
-
-            self.assertEqual(psdf.index.is_unique, expected)
-
-    def test_view(self):
-        pidx = pd.Index([1, 2, 3, 4], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.view(), psidx.view())
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(pmidx.view(), psmidx.view())
-
-    def test_insert(self):
-        # Integer
-        pidx = pd.Index([1, 2, 3], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.insert(1, 100), psidx.insert(1, 100))
-        self.assert_eq(pidx.insert(-1, 100), psidx.insert(-1, 100))
-        err_msg = "index 100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(100, 100)
-        err_msg = "index -100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(-100, 100)
-
-        # Floating
-        pidx = pd.Index([1.0, 2.0, 3.0], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.insert(1, 100.0), psidx.insert(1, 100.0))
-        self.assert_eq(pidx.insert(-1, 100.0), psidx.insert(-1, 100.0))
-        err_msg = "index 100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(100, 100)
-        err_msg = "index -100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(-100, 100)
-
-        # String
-        pidx = pd.Index(["a", "b", "c"], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.insert(1, "x"), psidx.insert(1, "x"))
-        self.assert_eq(pidx.insert(-1, "x"), psidx.insert(-1, "x"))
-        err_msg = "index 100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(100, "x")
-        err_msg = "index -100 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(-100, "x")
-
-        # Boolean
-        pidx = pd.Index([True, False, True, False], name="Koalas")
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(pidx.insert(1, True), psidx.insert(1, True))
-        self.assert_eq(pidx.insert(-1, True), psidx.insert(-1, True))
-        err_msg = "index 100 is out of bounds for axis 0 with size 4"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(100, True)
-        err_msg = "index -100 is out of bounds for axis 0 with size 4"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psidx.insert(-100, True)
-
-        # MultiIndex
-        pmidx = pd.MultiIndex.from_tuples(
-            [("a", "x"), ("b", "y"), ("c", "z")], names=["Hello", "Koalas"]
-        )
-        psmidx = ps.from_pandas(pmidx)
-        self.assert_eq(pmidx.insert(2, ("h", "j")), psmidx.insert(2, ("h", "j")))
-        self.assert_eq(pmidx.insert(-1, ("h", "j")), psmidx.insert(-1, ("h", "j")))
-
-        err_msg = "index 4 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psmidx.insert(4, ("b", "y"))
-
-        err_msg = "index -4 is out of bounds for axis 0 with size 3"
-        with self.assertRaisesRegex(IndexError, err_msg):
-            psmidx.insert(-4, ("b", "y"))
-
-    def test_astype(self):
-        pidx = pd.Index([10, 20, 15, 30, 45], name="x")
-        psidx = ps.Index(pidx)
-
-        self.assert_eq(psidx.astype(int), pidx.astype(int))
-        self.assert_eq(psidx.astype(np.int8), pidx.astype(np.int8))
-        self.assert_eq(psidx.astype(np.int16), pidx.astype(np.int16))
-        self.assert_eq(psidx.astype(np.int32), pidx.astype(np.int32))
-        self.assert_eq(psidx.astype(np.int64), pidx.astype(np.int64))
-        self.assert_eq(psidx.astype(np.byte), pidx.astype(np.byte))
-        self.assert_eq(psidx.astype("int"), pidx.astype("int"))
-        self.assert_eq(psidx.astype("int8"), pidx.astype("int8"))
-        self.assert_eq(psidx.astype("int16"), pidx.astype("int16"))
-        self.assert_eq(psidx.astype("int32"), pidx.astype("int32"))
-        self.assert_eq(psidx.astype("int64"), pidx.astype("int64"))
-        self.assert_eq(psidx.astype("b"), pidx.astype("b"))
-        self.assert_eq(psidx.astype("byte"), pidx.astype("byte"))
-        self.assert_eq(psidx.astype("i"), pidx.astype("i"))
-        self.assert_eq(psidx.astype("long"), pidx.astype("long"))
-        self.assert_eq(psidx.astype("short"), pidx.astype("short"))
-        self.assert_eq(psidx.astype(np.float32), pidx.astype(np.float32))
-        self.assert_eq(psidx.astype(np.float64), pidx.astype(np.float64))
-        self.assert_eq(psidx.astype("float"), pidx.astype("float"))
-        self.assert_eq(psidx.astype("float32"), pidx.astype("float32"))
-        self.assert_eq(psidx.astype("float64"), pidx.astype("float64"))
-        self.assert_eq(psidx.astype("double"), pidx.astype("double"))
-        self.assert_eq(psidx.astype("f"), pidx.astype("f"))
-        self.assert_eq(psidx.astype(bool), pidx.astype(bool))
-        self.assert_eq(psidx.astype("bool"), pidx.astype("bool"))
-        self.assert_eq(psidx.astype("?"), pidx.astype("?"))
-        self.assert_eq(psidx.astype(np.unicode_), pidx.astype(np.unicode_))
-        self.assert_eq(psidx.astype("str"), pidx.astype("str"))
-        self.assert_eq(psidx.astype("U"), pidx.astype("U"))
-
-        pidx = pd.Index([10, 20, 15, 30, 45, None], name="x")
-        psidx = ps.Index(pidx)
-        if LooseVersion(pd.__version__) >= LooseVersion("1.3"):
-            self.assert_eq(psidx.astype(bool), pidx.astype(bool))
-            self.assert_eq(psidx.astype(str), pidx.astype(str))
-        else:
-            self.assert_eq(
-                psidx.astype(bool), ps.Index([True, True, True, True, True, True], name="x")
-            )
-            self.assert_eq(
-                psidx.astype(str),
-                ps.Index(["10.0", "20.0", "15.0", "30.0", "45.0", "nan"], name="x"),
-            )
-
-        pidx = pd.Index(["hi", "hi ", " ", " \t", "", None], name="x")
-        psidx = ps.Index(pidx)
-
-        self.assert_eq(psidx.astype(bool), pidx.astype(bool))
-        self.assert_eq(psidx.astype(str), pidx.astype(str))
-
-        pidx = pd.Index([True, False, None], name="x")
-        psidx = ps.Index(pidx)
-
-        self.assert_eq(psidx.astype(bool), pidx.astype(bool))
-
-        pidx = pd.Index(["2020-10-27"], name="x")
-        psidx = ps.Index(pidx)
-
-        self.assert_eq(psidx.astype("datetime64[ns]"), pidx.astype("datetime64[ns]"))
-
-        with self.assertRaisesRegex(TypeError, "not understood"):
-            psidx.astype("int63")
-
-    def test_to_list(self):
-        # Index
-        pidx = pd.Index([1, 2, 3, 4, 5])
-        psidx = ps.from_pandas(pidx)
-        # MultiIndex
-        tuples = [(1, "red"), (1, "blue"), (2, "red"), (2, "green")]
-        pmidx = pd.MultiIndex.from_tuples(tuples)
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assert_eq(psidx.tolist(), pidx.tolist())
-        self.assert_eq(psmidx.tolist(), pmidx.tolist())
-
-    def test_index_ops(self):
-        pidx = pd.Index([1, 2, 3, 4, 5])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx * 100 + psidx * 10 + psidx, pidx * 100 + pidx * 10 + pidx)
-
-        pidx = pd.Index([1, 2, 3, 4, 5], name="a")
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(psidx * 100 + psidx * 10 + psidx, pidx * 100 + pidx * 10 + pidx)
-
-        pdf = pd.DataFrame(
-            index=pd.MultiIndex.from_tuples([(1, 2), (3, 4), (5, 6)], names=["a", "b"])
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pidx1 = pdf.index.get_level_values(0)
-        pidx2 = pdf.index.get_level_values(1)
-        psidx1 = psdf.index.get_level_values(0)
-        psidx2 = psdf.index.get_level_values(1)
-
-        self.assert_eq(psidx1 * 10 + psidx2, pidx1 * 10 + pidx2)
-
-    def test_factorize(self):
-        pidx = pd.Index(["a", "b", "a", "b"])
-        psidx = ps.from_pandas(pidx)
-        pcodes, puniques = pidx.factorize(sort=True)
-        kcodes, kuniques = psidx.factorize()
-        self.assert_eq(pcodes.tolist(), kcodes.to_list())
-        self.assert_eq(puniques, kuniques)
-
-        pmidx = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("y", "c")])
-        psmidx = ps.from_pandas(pmidx)
-
-        self.assertRaises(PandasNotImplementedError, lambda: psmidx.factorize())
-
-    def test_map(self):
-        pidx = pd.Index([1, 2, 3])
-        psidx = ps.from_pandas(pidx)
-
-        # Apply dict
-        self.assert_eq(
-            pidx.map({1: "one", 2: "two", 3: "three"}),
-            psidx.map({1: "one", 2: "two", 3: "three"}),
-        )
-        self.assert_eq(
-            pidx.map({1: "one", 2: "two"}),
-            psidx.map({1: "one", 2: "two"}),
-        )
-        self.assert_eq(
-            pidx.map({1: "one", 2: "two"}, na_action="ignore"),
-            psidx.map({1: "one", 2: "two"}, na_action="ignore"),
-        )
-        self.assert_eq(
-            pidx.map({1: 10, 2: 20}),
-            psidx.map({1: 10, 2: 20}),
-        )
-        self.assert_eq(
-            (pidx + 1).map({1: 10, 2: 20}),
-            (psidx + 1).map({1: 10, 2: 20}),
-        )
-
-        # Apply lambda
-        self.assert_eq(
-            pidx.map(lambda id: id + 1),
-            psidx.map(lambda id: id + 1),
-        )
-        self.assert_eq(
-            pidx.map(lambda id: id + 1.1),
-            psidx.map(lambda id: id + 1.1),
-        )
-        self.assert_eq(
-            pidx.map(lambda id: "{id} + 1".format(id=id)),
-            psidx.map(lambda id: "{id} + 1".format(id=id)),
-        )
-        self.assert_eq(
-            (pidx + 1).map(lambda id: "{id} + 1".format(id=id)),
-            (psidx + 1).map(lambda id: "{id} + 1".format(id=id)),
-        )
-
-        # Apply series
-        pser = pd.Series(["one", "two", "three"], index=[1, 2, 3])
-        self.assert_eq(
-            pidx.map(pser),
-            psidx.map(pser),
-        )
-        pser = pd.Series(["one", "two", "three"])
-        self.assert_eq(
-            pidx.map(pser),
-            psidx.map(pser),
-        )
-        self.assert_eq(
-            pidx.map(pser, na_action="ignore"),
-            psidx.map(pser, na_action="ignore"),
-        )
-        pser = pd.Series([1, 2, 3])
-        self.assert_eq(
-            pidx.map(pser),
-            psidx.map(pser),
-        )
-        self.assert_eq(
-            (pidx + 1).map(pser),
-            (psidx + 1).map(pser),
-        )
-
-        self.assertRaises(
-            TypeError,
-            lambda: psidx.map({1: 1, 2: 2.0, 3: "three"}),
-        )
-
-    def test_multiindex_equal_levels(self):
-        pmidx1 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        pmidx2 = pd.MultiIndex.from_tuples([("b", "y"), ("a", "x"), ("c", "z")])
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "j")])
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("a", "x")])
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y")])
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "y"), ("b", "x"), ("c", "z")])
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx1 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z"), ("a", "y")])
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "y"), ("b", "x"), ("c", "z"), ("c", "x")])
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-        pmidx1 = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y"), ("c", "z")])
-        pmidx2 = pd.MultiIndex.from_tuples([("a", "x", "q"), ("b", "y", "w"), ("c", "z", "e")])
-        psmidx1 = ps.from_pandas(pmidx1)
-        psmidx2 = ps.from_pandas(pmidx2)
-        self.assert_eq(pmidx1.equal_levels(pmidx2), psmidx1.equal_levels(psmidx2))
-
-    def test_to_numpy(self):
-        pidx = pd.Index([1, 2, 3, 4])
-        psidx = ps.from_pandas(pidx)
-
-        self.assert_eq(pidx.to_numpy(copy=True), psidx.to_numpy(copy=True))
-
-    def test_drop_level(self):
-        tuples = [(1, "red"), (1, "blue"), (2, "red"), (2, "green")]
-        pmidx = pd.MultiIndex.from_tuples(tuples)
-        psmidx = ps.from_pandas(pmidx)
-
-        with self.assertRaisesRegex(
-            IndexError, "Too many levels: Index has only 2 levels, -3 is not a valid level number"
-        ):
-            psmidx.droplevel(-3)
-
-    def test_multi_index_nunique(self):
-        tuples = [(1, "red"), (1, "blue"), (2, "red"), (2, "green")]
-        pmidx = pd.MultiIndex.from_tuples(tuples)
-        psmidx = ps.from_pandas(pmidx)
-
-        with self.assertRaisesRegex(NotImplementedError, "nunique is not defined for MultiIndex"):
-            psmidx.nunique()
-
-
-class IndexesTests(IndexesTestsMixin, ComparisonTestBase, TestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.indexes.test_base import *  # noqa: F401
-
-    try:
-        import xmlrunner
-
-        testRunner = xmlrunner.XMLTestRunner(output="target/test-reports", verbosity=2)
-    except ImportError:
-        testRunner = None
-    unittest.main(testRunner=testRunner, verbosity=2)