snowpark-connect 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/test_indexing.py

@@ -1,1339 +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 datetime
-from distutils.version import LooseVersion
-import unittest
-
-import numpy as np
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.pandas.exceptions import SparkPandasIndexingError
-from pyspark.testing.pandasutils import ComparisonTestBase, compare_both
-
-
-class BasicIndexingTestsMixin:
-    @property
-    def pdf(self):
-        return pd.DataFrame(
-            {"month": [1, 4, 7, 10], "year": [2012, 2014, 2013, 2014], "sale": [55, 40, 84, 31]}
-        )
-
-    @compare_both(almost=False)
-    def test_indexing(self, df):
-        df1 = df.set_index("month")
-        yield df1
-
-        yield df.set_index("month", drop=False)
-        yield df.set_index("month", append=True)
-        yield df.set_index(["year", "month"])
-        yield df.set_index(["year", "month"], drop=False)
-        yield df.set_index(["year", "month"], append=True)
-
-        yield df1.set_index("year", drop=False, append=True)
-
-        df2 = df1.copy()
-        df2.set_index("year", append=True, inplace=True)
-        yield df2
-
-        self.assertRaisesRegex(KeyError, "unknown", lambda: df.set_index("unknown"))
-        self.assertRaisesRegex(KeyError, "unknown", lambda: df.set_index(["month", "unknown"]))
-
-        for d in [df, df1, df2]:
-            yield d.reset_index()
-            yield d.reset_index(drop=True)
-
-        yield df1.reset_index(level=0)
-        yield df2.reset_index(level=1)
-        yield df2.reset_index(level=[1, 0])
-        yield df1.reset_index(level="month")
-        yield df2.reset_index(level="year")
-        yield df2.reset_index(level=["month", "year"])
-        yield df2.reset_index(level="month", drop=True)
-        yield df2.reset_index(level=["month", "year"], drop=True)
-
-        self.assertRaisesRegex(
-            IndexError,
-            "Too many levels: Index has only 1 level, not 3",
-            lambda: df1.reset_index(level=2),
-        )
-        self.assertRaisesRegex(
-            IndexError,
-            "Too many levels: Index has only 1 level, not 4",
-            lambda: df1.reset_index(level=[3, 2]),
-        )
-        self.assertRaisesRegex(KeyError, "unknown.*month", lambda: df1.reset_index(level="unknown"))
-        self.assertRaisesRegex(
-            KeyError, "Level unknown not found", lambda: df2.reset_index(level="unknown")
-        )
-
-        df3 = df2.copy()
-        df3.reset_index(inplace=True)
-        yield df3
-
-        yield df1.sale.reset_index()
-        yield df1.sale.reset_index(level=0)
-        yield df2.sale.reset_index(level=[1, 0])
-        yield df1.sale.reset_index(drop=True)
-        yield df1.sale.reset_index(name="s")
-        yield df1.sale.reset_index(name="s", drop=True)
-
-        s = df1.sale
-        self.assertRaisesRegex(
-            TypeError,
-            "Cannot reset_index inplace on a Series to create a DataFrame",
-            lambda: s.reset_index(inplace=True),
-        )
-        s.reset_index(drop=True, inplace=True)
-        yield s
-        yield df1
-
-        # multi-index columns
-        df4 = df.copy()
-        df4.columns = pd.MultiIndex.from_tuples(
-            [("cal", "month"), ("cal", "year"), ("num", "sale")]
-        )
-        df5 = df4.set_index(("cal", "month"))
-        yield df5
-        yield df4.set_index([("cal", "month"), ("num", "sale")])
-
-        self.assertRaises(KeyError, lambda: df5.reset_index(level=("cal", "month")))
-
-        yield df5.reset_index(level=[("cal", "month")])
-
-        # non-string names
-        df6 = df.copy()
-        df6.columns = [10.0, 20.0, 30.0]
-        df7 = df6.set_index(10.0)
-        yield df7
-        yield df6.set_index([10.0, 30.0])
-
-        yield df7.reset_index(level=10.0)
-        yield df7.reset_index(level=[10.0])
-
-        df8 = df.copy()
-        df8.columns = pd.MultiIndex.from_tuples([(10, "month"), (10, "year"), (20, "sale")])
-        df9 = df8.set_index((10, "month"))
-        yield df9
-        yield df8.set_index([(10, "month"), (20, "sale")])
-
-        yield df9.reset_index(level=[(10, "month")])
-
-    def test_from_pandas_with_explicit_index(self):
-        pdf = self.pdf
-
-        df1 = ps.from_pandas(pdf.set_index("month"))
-        self.assertPandasEqual(df1._to_pandas(), pdf.set_index("month"))
-
-        df2 = ps.from_pandas(pdf.set_index(["year", "month"]))
-        self.assertPandasEqual(df2._to_pandas(), pdf.set_index(["year", "month"]))
-
-    def test_limitations(self):
-        df = self.psdf.set_index("month")
-
-        self.assertRaisesRegex(
-            ValueError,
-            "Level should be all int or all string.",
-            lambda: df.reset_index([1, "month"]),
-        )
-
-
-class IndexingTest(ComparisonTestBase):
-    @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],
-        )
-
-    @property
-    def pdf2(self):
-        return pd.DataFrame(
-            {0: [1, 2, 3, 4, 5, 6, 7, 8, 9], 1: [4, 5, 6, 3, 2, 1, 0, 0, 0]},
-            index=[0, 1, 3, 5, 6, 8, 9, 9, 9],
-        )
-
-    @property
-    def psdf2(self):
-        return ps.from_pandas(self.pdf2)
-
-    def test_at(self):
-        pdf = self.pdf
-        psdf = self.psdf
-        # Create the equivalent of pdf.loc[3] as a Koalas Series
-        # This is necessary because .loc[n] does not currently work with Koalas DataFrames (#383)
-        test_series = ps.Series([3, 6], index=["a", "b"], name="3")
-
-        # Assert invalided signatures raise TypeError
-        with self.assertRaises(TypeError, msg="Use DataFrame.at like .at[row_index, column_name]"):
-            psdf.at[3]
-        with self.assertRaises(TypeError, msg="Use DataFrame.at like .at[row_index, column_name]"):
-            psdf.at["ab"]  # 'ab' is of length 2 but str type instead of tuple
-        with self.assertRaises(TypeError, msg="Use Series.at like .at[column_name]"):
-            test_series.at[3, "b"]
-
-        # Assert .at for DataFrames
-        self.assertEqual(psdf.at[3, "b"], 6)
-        self.assertEqual(psdf.at[3, "b"], pdf.at[3, "b"])
-        self.assert_eq(psdf.at[9, "b"], np.array([0, 0, 0]))
-        self.assert_eq(psdf.at[9, "b"], pdf.at[9, "b"])
-
-        # Assert .at for Series
-        self.assertEqual(test_series.at["b"], 6)
-        self.assertEqual(test_series.at["b"], pdf.loc[3].at["b"])
-
-        # Assert multi-character indices
-        self.assertEqual(
-            ps.Series([0, 1], index=["ab", "cd"]).at["ab"],
-            pd.Series([0, 1], index=["ab", "cd"]).at["ab"],
-        )
-
-        # Assert invalid column or index names result in a KeyError like with pandas
-        with self.assertRaises(KeyError, msg="x"):
-            psdf.at[3, "x"]
-        with self.assertRaises(KeyError, msg=99):
-            psdf.at[99, "b"]
-
-        with self.assertRaises(ValueError):
-            psdf.at[(3, 6), "b"]
-        with self.assertRaises(KeyError):
-            psdf.at[3, ("x", "b")]
-
-        # Assert setting values fails
-        with self.assertRaises(TypeError):
-            psdf.at[3, "b"] = 10
-
-        # non-string column names
-        pdf = self.pdf2
-        psdf = self.psdf2
-
-        # Assert .at for DataFrames
-        self.assertEqual(psdf.at[3, 1], 6)
-        self.assertEqual(psdf.at[3, 1], pdf.at[3, 1])
-        self.assert_eq(psdf.at[9, 1], np.array([0, 0, 0]))
-        self.assert_eq(psdf.at[9, 1], pdf.at[9, 1])
-
-    def test_at_multiindex(self):
-        pdf = self.pdf.set_index("b", append=True)
-        psdf = self.psdf.set_index("b", append=True)
-
-        # TODO: seems like a pandas' bug in pandas>=1.1.0
-        if LooseVersion(pd.__version__) < LooseVersion("1.1.0"):
-            self.assert_eq(psdf.at[(3, 6), "a"], pdf.at[(3, 6), "a"])
-            self.assert_eq(psdf.at[(3,), "a"], pdf.at[(3,), "a"])
-            self.assert_eq(list(psdf.at[(9, 0), "a"]), list(pdf.at[(9, 0), "a"]))
-            self.assert_eq(list(psdf.at[(9,), "a"]), list(pdf.at[(9,), "a"]))
-        else:
-            self.assert_eq(psdf.at[(3, 6), "a"], 3)
-            self.assert_eq(psdf.at[(3,), "a"], np.array([3]))
-            self.assert_eq(list(psdf.at[(9, 0), "a"]), [7, 8, 9])
-            self.assert_eq(list(psdf.at[(9,), "a"]), [7, 8, 9])
-
-        with self.assertRaises(ValueError):
-            psdf.at[3, "a"]
-
-    def test_at_multiindex_columns(self):
-        arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.at["B", ("bar", "one")], pdf.at["B", ("bar", "one")])
-
-        with self.assertRaises(KeyError):
-            psdf.at["B", "bar"]
-
-        # non-string column names
-        arrays = [np.array([0, 0, 1, 1]), np.array([1, 2, 1, 2])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.at["B", (0, 1)], pdf.at["B", (0, 1)])
-
-    def test_iat(self):
-        pdf = self.pdf
-        psdf = self.psdf
-        # Create the equivalent of pdf.loc[3] as a Koalas Series
-        # This is necessary because .loc[n] does not currently work with Koalas DataFrames (#383)
-        test_series = ps.Series([3, 6], index=["a", "b"], name="3")
-
-        # Assert invalided signatures raise TypeError
-        with self.assertRaises(
-            TypeError,
-            msg="Use DataFrame.at like .iat[row_interget_position, column_integer_position]",
-        ):
-            psdf.iat[3]
-        with self.assertRaises(
-            ValueError, msg="iAt based indexing on multi-index can only have tuple values"
-        ):
-            psdf.iat[3, "b"]  # 'ab' is of length 2 but str type instead of tuple
-        with self.assertRaises(TypeError, msg="Use Series.iat like .iat[row_integer_position]"):
-            test_series.iat[3, "b"]
-
-        # Assert .iat for DataFrames
-        self.assertEqual(psdf.iat[7, 0], 8)
-        self.assertEqual(psdf.iat[7, 0], pdf.iat[7, 0])
-
-        # Assert .iat for Series
-        self.assertEqual(test_series.iat[1], 6)
-        self.assertEqual(test_series.iat[1], pdf.loc[3].iat[1])
-
-        # Assert invalid column or integer position result in a KeyError like with pandas
-        with self.assertRaises(KeyError, msg=99):
-            psdf.iat[0, 99]
-        with self.assertRaises(KeyError, msg=99):
-            psdf.iat[99, 0]
-
-        with self.assertRaises(ValueError):
-            psdf.iat[(1, 1), 1]
-        with self.assertRaises(ValueError):
-            psdf.iat[1, (1, 1)]
-
-        # Assert setting values fails
-        with self.assertRaises(TypeError):
-            psdf.iat[4, 1] = 10
-
-    def test_iat_multiindex(self):
-        pdf = self.pdf.set_index("b", append=True)
-        psdf = self.psdf.set_index("b", append=True)
-
-        self.assert_eq(psdf.iat[7, 0], pdf.iat[7, 0])
-
-        with self.assertRaises(ValueError):
-            psdf.iat[3, "a"]
-
-    def test_iat_multiindex_columns(self):
-        arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.iat[1, 3], pdf.iat[1, 3])
-
-        with self.assertRaises(KeyError):
-            psdf.iat[0, 99]
-        with self.assertRaises(KeyError):
-            psdf.iat[99, 0]
-
-    def test_loc(self):
-        psdf = self.psdf
-        pdf = self.pdf
-
-        self.assert_eq(psdf.loc[5:5], pdf.loc[5:5])
-        self.assert_eq(psdf.loc[3:8], pdf.loc[3:8])
-        self.assert_eq(psdf.loc[:8], pdf.loc[:8])
-        self.assert_eq(psdf.loc[3:], pdf.loc[3:])
-        self.assert_eq(psdf.loc[[5]], pdf.loc[[5]])
-        self.assert_eq(psdf.loc[:], pdf.loc[:])
-
-        # TODO?: self.assert_eq(psdf.loc[[3, 4, 1, 8]], pdf.loc[[3, 4, 1, 8]])
-        # TODO?: self.assert_eq(psdf.loc[[3, 4, 1, 9]], pdf.loc[[3, 4, 1, 9]])
-        # TODO?: self.assert_eq(psdf.loc[np.array([3, 4, 1, 9])], pdf.loc[np.array([3, 4, 1, 9])])
-
-        self.assert_eq(psdf.a.loc[5:5], pdf.a.loc[5:5])
-        self.assert_eq(psdf.a.loc[3:8], pdf.a.loc[3:8])
-        self.assert_eq(psdf.a.loc[:8], pdf.a.loc[:8])
-        self.assert_eq(psdf.a.loc[3:], pdf.a.loc[3:])
-        self.assert_eq(psdf.a.loc[[5]], pdf.a.loc[[5]])
-
-        # TODO?: self.assert_eq(psdf.a.loc[[3, 4, 1, 8]], pdf.a.loc[[3, 4, 1, 8]])
-        # TODO?: self.assert_eq(psdf.a.loc[[3, 4, 1, 9]], pdf.a.loc[[3, 4, 1, 9]])
-        # TODO?: self.assert_eq(psdf.a.loc[np.array([3, 4, 1, 9])],
-        #                       pdf.a.loc[np.array([3, 4, 1, 9])])
-
-        self.assert_eq(psdf.a.loc[[]], pdf.a.loc[[]])
-        self.assert_eq(psdf.a.loc[np.array([])], pdf.a.loc[np.array([])])
-
-        self.assert_eq(psdf.loc[1000:], pdf.loc[1000:])
-        self.assert_eq(psdf.loc[-2000:-1000], pdf.loc[-2000:-1000])
-
-        self.assert_eq(psdf.loc[5], pdf.loc[5])
-        self.assert_eq(psdf.loc[9], pdf.loc[9])
-        self.assert_eq(psdf.a.loc[5], pdf.a.loc[5])
-        self.assert_eq(psdf.a.loc[9], pdf.a.loc[9])
-
-        self.assertRaises(KeyError, lambda: psdf.loc[10])
-        self.assertRaises(KeyError, lambda: psdf.a.loc[10])
-
-        # monotonically increasing index test
-        pdf = pd.DataFrame({"a": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, index=[0, 1, 1, 2, 2, 2, 4, 5, 6])
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc[:2], pdf.loc[:2])
-        self.assert_eq(psdf.loc[:3], pdf.loc[:3])
-        self.assert_eq(psdf.loc[3:], pdf.loc[3:])
-        self.assert_eq(psdf.loc[4:], pdf.loc[4:])
-        self.assert_eq(psdf.loc[3:2], pdf.loc[3:2])
-        self.assert_eq(psdf.loc[-1:2], pdf.loc[-1:2])
-        self.assert_eq(psdf.loc[3:10], pdf.loc[3:10])
-
-        # monotonically decreasing index test
-        pdf = pd.DataFrame({"a": [1, 2, 3, 4, 5, 6, 7, 8, 9]}, index=[6, 5, 5, 4, 4, 4, 2, 1, 0])
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc[:4], pdf.loc[:4])
-        self.assert_eq(psdf.loc[:3], pdf.loc[:3])
-        self.assert_eq(psdf.loc[3:], pdf.loc[3:])
-        self.assert_eq(psdf.loc[2:], pdf.loc[2:])
-        self.assert_eq(psdf.loc[2:3], pdf.loc[2:3])
-        self.assert_eq(psdf.loc[2:-1], pdf.loc[2:-1])
-        self.assert_eq(psdf.loc[10:3], pdf.loc[10:3])
-
-        # test when type of key is string and given value is not included in key
-        pdf = pd.DataFrame({"a": [1, 2, 3]}, index=["a", "b", "d"])
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc["a":"z"], pdf.loc["a":"z"])
-
-        # KeyError when index is not monotonic increasing or decreasing
-        # and specified values don't exist in index
-        psdf = ps.DataFrame([[1, 2], [4, 5], [7, 8]], index=["cobra", "viper", "sidewinder"])
-
-        self.assertRaises(KeyError, lambda: psdf.loc["cobra":"koalas"])
-        self.assertRaises(KeyError, lambda: psdf.loc["koalas":"viper"])
-
-        psdf = ps.DataFrame([[1, 2], [4, 5], [7, 8]], index=[10, 30, 20])
-
-        self.assertRaises(KeyError, lambda: psdf.loc[0:30])
-        self.assertRaises(KeyError, lambda: psdf.loc[10:100])
-
-    def test_loc_getitem_boolean_series(self):
-        pdf = pd.DataFrame(
-            {"A": [0, 1, 2, 3, 4], "B": [100, 200, 300, 400, 500]}, index=[20, 10, 30, 0, 50]
-        )
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(pdf.A.loc[pdf.B > 200], psdf.A.loc[psdf.B > 200])
-        self.assert_eq(pdf.B.loc[pdf.B > 200], psdf.B.loc[psdf.B > 200])
-        self.assert_eq(pdf.loc[pdf.B > 200], psdf.loc[psdf.B > 200])
-
-    def test_loc_non_informative_index(self):
-        pdf = pd.DataFrame({"x": [1, 2, 3, 4]}, index=[10, 20, 30, 40])
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc[20:30], pdf.loc[20:30])
-
-        pdf = pd.DataFrame({"x": [1, 2, 3, 4]}, index=[10, 20, 20, 40])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf.loc[20:20], pdf.loc[20:20])
-
-    def test_loc_with_series(self):
-        psdf = self.psdf
-        pdf = self.pdf
-
-        self.assert_eq(psdf.loc[psdf.a % 2 == 0], pdf.loc[pdf.a % 2 == 0])
-        self.assert_eq(psdf.loc[psdf.a % 2 == 0, "a"], pdf.loc[pdf.a % 2 == 0, "a"])
-        self.assert_eq(psdf.loc[psdf.a % 2 == 0, ["a"]], pdf.loc[pdf.a % 2 == 0, ["a"]])
-        self.assert_eq(psdf.a.loc[psdf.a % 2 == 0], pdf.a.loc[pdf.a % 2 == 0])
-
-        self.assert_eq(psdf.loc[psdf.copy().a % 2 == 0], pdf.loc[pdf.copy().a % 2 == 0])
-        self.assert_eq(psdf.loc[psdf.copy().a % 2 == 0, "a"], pdf.loc[pdf.copy().a % 2 == 0, "a"])
-        self.assert_eq(
-            psdf.loc[psdf.copy().a % 2 == 0, ["a"]], pdf.loc[pdf.copy().a % 2 == 0, ["a"]]
-        )
-        self.assert_eq(psdf.a.loc[psdf.copy().a % 2 == 0], pdf.a.loc[pdf.copy().a % 2 == 0])
-
-    def test_loc_noindex(self):
-        psdf = self.psdf
-        psdf = psdf.reset_index()
-        pdf = self.pdf
-        pdf = pdf.reset_index()
-
-        self.assert_eq(psdf[["a"]], pdf[["a"]])
-
-        self.assert_eq(psdf.loc[:], pdf.loc[:])
-        self.assert_eq(psdf.loc[5:5], pdf.loc[5:5])
-
-    def test_loc_multiindex(self):
-        psdf = self.psdf
-        psdf = psdf.set_index("b", append=True)
-        pdf = self.pdf
-        pdf = pdf.set_index("b", append=True)
-
-        self.assert_eq(psdf.loc[:], pdf.loc[:])
-        self.assert_eq(psdf.loc[5:5], pdf.loc[5:5])
-        self.assert_eq(psdf.loc[5:9], pdf.loc[5:9])
-
-        self.assert_eq(psdf.loc[5], pdf.loc[5])
-        self.assert_eq(psdf.loc[9], pdf.loc[9])
-        # TODO: self.assert_eq(psdf.loc[(5, 3)], pdf.loc[(5, 3)])
-        # TODO: self.assert_eq(psdf.loc[(9, 0)], pdf.loc[(9, 0)])
-        self.assert_eq(psdf.a.loc[5], pdf.a.loc[5])
-        self.assert_eq(psdf.a.loc[9], pdf.a.loc[9])
-        self.assertTrue((psdf.a.loc[(5, 3)] == pdf.a.loc[(5, 3)]).all())
-        self.assert_eq(psdf.a.loc[(9, 0)], pdf.a.loc[(9, 0)])
-
-        # monotonically increasing index test
-        pdf = pd.DataFrame(
-            {"a": [1, 2, 3, 4, 5]},
-            index=pd.MultiIndex.from_tuples(
-                [("x", "a"), ("x", "b"), ("y", "c"), ("y", "d"), ("z", "e")]
-            ),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        for rows_sel in [
-            slice(None),
-            slice("y", None),
-            slice(None, "y"),
-            slice(("x", "b"), None),
-            slice(None, ("y", "c")),
-            slice(("x", "b"), ("y", "c")),
-            slice("x", ("y", "c")),
-            slice(("x", "b"), "y"),
-        ]:
-            with self.subTest("monotonically increasing", rows_sel=rows_sel):
-                self.assert_eq(psdf.loc[rows_sel], pdf.loc[rows_sel])
-                self.assert_eq(psdf.a.loc[rows_sel], pdf.a.loc[rows_sel])
-
-        # monotonically increasing first index test
-        pdf = pd.DataFrame(
-            {"a": [1, 2, 3, 4, 5]},
-            index=pd.MultiIndex.from_tuples(
-                [("x", "a"), ("x", "b"), ("y", "c"), ("y", "a"), ("z", "e")]
-            ),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        for rows_sel in [
-            slice(None),
-            slice("y", None),
-            slice(None, "y"),
-        ]:
-            with self.subTest("monotonically increasing first index", rows_sel=rows_sel):
-                self.assert_eq(psdf.loc[rows_sel], pdf.loc[rows_sel])
-                self.assert_eq(psdf.a.loc[rows_sel], pdf.a.loc[rows_sel])
-
-        for rows_sel in [
-            slice(("x", "b"), None),
-            slice(None, ("y", "c")),
-            slice(("x", "b"), ("y", "c")),
-            slice("x", ("y", "c")),
-            slice(("x", "b"), "y"),
-        ]:
-            with self.subTest("monotonically increasing first index", rows_sel=rows_sel):
-                self.assertRaises(KeyError, lambda: psdf.loc[rows_sel])
-                self.assertRaises(KeyError, lambda: psdf.a.loc[rows_sel])
-
-        # not monotonically increasing index test
-        pdf = pd.DataFrame(
-            {"a": [1, 2, 3, 4, 5]},
-            index=pd.MultiIndex.from_tuples(
-                [("z", "e"), ("y", "d"), ("y", "c"), ("x", "b"), ("x", "a")]
-            ),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        for rows_sel in [
-            slice("y", None),
-            slice(None, "y"),
-            slice(("x", "b"), None),
-            slice(None, ("y", "c")),
-            slice(("x", "b"), ("y", "c")),
-            slice("x", ("y", "c")),
-            slice(("x", "b"), "y"),
-        ]:
-            with self.subTest("monotonically decreasing", rows_sel=rows_sel):
-                self.assertRaises(KeyError, lambda: psdf.loc[rows_sel])
-                self.assertRaises(KeyError, lambda: psdf.a.loc[rows_sel])
-
-    def test_loc2d_multiindex(self):
-        psdf = self.psdf
-        psdf = psdf.set_index("b", append=True)
-        pdf = self.pdf
-        pdf = pdf.set_index("b", append=True)
-
-        self.assert_eq(psdf.loc[:, :], pdf.loc[:, :])
-        self.assert_eq(psdf.loc[:, "a"], pdf.loc[:, "a"])
-        self.assert_eq(psdf.loc[5:5, "a"], pdf.loc[5:5, "a"])
-
-        self.assert_eq(psdf.loc[:, "a":"a"], pdf.loc[:, "a":"a"])
-        self.assert_eq(psdf.loc[:, "a":"c"], pdf.loc[:, "a":"c"])
-        self.assert_eq(psdf.loc[:, "b":"c"], pdf.loc[:, "b":"c"])
-
-    def test_loc2d(self):
-        psdf = self.psdf
-        pdf = self.pdf
-
-        # index indexer is always regarded as slice for duplicated values
-        self.assert_eq(psdf.loc[5:5, "a"], pdf.loc[5:5, "a"])
-        self.assert_eq(psdf.loc[[5], "a"], pdf.loc[[5], "a"])
-        self.assert_eq(psdf.loc[5:5, ["a"]], pdf.loc[5:5, ["a"]])
-        self.assert_eq(psdf.loc[[5], ["a"]], pdf.loc[[5], ["a"]])
-        self.assert_eq(psdf.loc[:, :], pdf.loc[:, :])
-
-        self.assert_eq(psdf.loc[3:8, "a"], pdf.loc[3:8, "a"])
-        self.assert_eq(psdf.loc[:8, "a"], pdf.loc[:8, "a"])
-        self.assert_eq(psdf.loc[3:, "a"], pdf.loc[3:, "a"])
-        self.assert_eq(psdf.loc[[8], "a"], pdf.loc[[8], "a"])
-
-        self.assert_eq(psdf.loc[3:8, ["a"]], pdf.loc[3:8, ["a"]])
-        self.assert_eq(psdf.loc[:8, ["a"]], pdf.loc[:8, ["a"]])
-        self.assert_eq(psdf.loc[3:, ["a"]], pdf.loc[3:, ["a"]])
-        # TODO?: self.assert_eq(psdf.loc[[3, 4, 3], ['a']], pdf.loc[[3, 4, 3], ['a']])
-
-        self.assertRaises(SparkPandasIndexingError, lambda: psdf.loc[3, 3, 3])
-        self.assertRaises(SparkPandasIndexingError, lambda: psdf.a.loc[3, 3])
-        self.assertRaises(SparkPandasIndexingError, lambda: psdf.a.loc[3:, 3])
-        self.assertRaises(SparkPandasIndexingError, lambda: psdf.a.loc[psdf.a % 2 == 0, 3])
-
-        self.assert_eq(psdf.loc[5, "a"], pdf.loc[5, "a"])
-        self.assert_eq(psdf.loc[9, "a"], pdf.loc[9, "a"])
-        self.assert_eq(psdf.loc[5, ["a"]], pdf.loc[5, ["a"]])
-        self.assert_eq(psdf.loc[9, ["a"]], pdf.loc[9, ["a"]])
-
-        self.assert_eq(psdf.loc[:, "a":"a"], pdf.loc[:, "a":"a"])
-        self.assert_eq(psdf.loc[:, "a":"d"], pdf.loc[:, "a":"d"])
-        self.assert_eq(psdf.loc[:, "c":"d"], pdf.loc[:, "c":"d"])
-
-        # bool list-like column select
-        bool_list = [True, False]
-        self.assert_eq(psdf.loc[:, bool_list], pdf.loc[:, bool_list])
-        self.assert_eq(psdf.loc[:, np.array(bool_list)], pdf.loc[:, np.array(bool_list)])
-
-        pser = pd.Series(bool_list, index=pdf.columns)
-        self.assert_eq(psdf.loc[:, pser], pdf.loc[:, pser])
-        pser = pd.Series(list(reversed(bool_list)), index=list(reversed(pdf.columns)))
-        self.assert_eq(psdf.loc[:, pser], pdf.loc[:, pser])
-
-        self.assertRaises(IndexError, lambda: psdf.loc[:, bool_list[:-1]])
-        self.assertRaises(IndexError, lambda: psdf.loc[:, np.array(bool_list + [True])])
-        self.assertRaises(SparkPandasIndexingError, lambda: psdf.loc[:, pd.Series(bool_list)])
-
-        # non-string column names
-        psdf = self.psdf2
-        pdf = self.pdf2
-
-        self.assert_eq(psdf.loc[5:5, 0], pdf.loc[5:5, 0])
-        self.assert_eq(psdf.loc[5:5, [0]], pdf.loc[5:5, [0]])
-        self.assert_eq(psdf.loc[3:8, 0], pdf.loc[3:8, 0])
-        self.assert_eq(psdf.loc[3:8, [0]], pdf.loc[3:8, [0]])
-
-        self.assert_eq(psdf.loc[:, 0:0], pdf.loc[:, 0:0])
-        self.assert_eq(psdf.loc[:, 0:3], pdf.loc[:, 0:3])
-        self.assert_eq(psdf.loc[:, 2:3], pdf.loc[:, 2:3])
-
-    def test_loc2d_multiindex_columns(self):
-        arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc["B":"B", "bar"], pdf.loc["B":"B", "bar"])
-        self.assert_eq(psdf.loc["B":"B", ["bar"]], pdf.loc["B":"B", ["bar"]])
-
-        self.assert_eq(psdf.loc[:, "bar":"bar"], pdf.loc[:, "bar":"bar"])
-        self.assert_eq(psdf.loc[:, "bar":("baz", "one")], pdf.loc[:, "bar":("baz", "one")])
-        self.assert_eq(
-            psdf.loc[:, ("bar", "two"):("baz", "one")], pdf.loc[:, ("bar", "two"):("baz", "one")]
-        )
-        self.assert_eq(psdf.loc[:, ("bar", "two"):"bar"], pdf.loc[:, ("bar", "two"):"bar"])
-        self.assert_eq(psdf.loc[:, "a":"bax"], pdf.loc[:, "a":"bax"])
-        self.assert_eq(
-            psdf.loc[:, ("bar", "x"):("baz", "a")],
-            pdf.loc[:, ("bar", "x"):("baz", "a")],
-            almost=True,
-        )
-
-        pdf = pd.DataFrame(
-            np.random.randn(3, 4),
-            index=["A", "B", "C"],
-            columns=pd.MultiIndex.from_tuples(
-                [("bar", "two"), ("bar", "one"), ("baz", "one"), ("baz", "two")]
-            ),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc[:, "bar":"baz"], pdf.loc[:, "bar":"baz"])
-
-        self.assertRaises(KeyError, lambda: psdf.loc[:, "bar":("baz", "one")])
-        self.assertRaises(KeyError, lambda: psdf.loc[:, ("bar", "two"):"bar"])
-
-        # bool list-like column select
-        bool_list = [True, False, True, False]
-        self.assert_eq(psdf.loc[:, bool_list], pdf.loc[:, bool_list])
-        self.assert_eq(psdf.loc[:, np.array(bool_list)], pdf.loc[:, np.array(bool_list)])
-
-        pser = pd.Series(bool_list, index=pdf.columns)
-        self.assert_eq(psdf.loc[:, pser], pdf.loc[:, pser])
-
-        pser = pd.Series(list(reversed(bool_list)), index=list(reversed(pdf.columns)))
-        self.assert_eq(psdf.loc[:, pser], pdf.loc[:, pser])
-
-        # non-string column names
-        arrays = [np.array([0, 0, 1, 1]), np.array([1, 2, 1, 2])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc["B":"B", 0], pdf.loc["B":"B", 0])
-        self.assert_eq(psdf.loc["B":"B", [0]], pdf.loc["B":"B", [0]])
-        self.assert_eq(psdf.loc[:, 0:0], pdf.loc[:, 0:0])
-        self.assert_eq(psdf.loc[:, 0:(1, 1)], pdf.loc[:, 0:(1, 1)])
-        self.assert_eq(psdf.loc[:, (0, 2):(1, 1)], pdf.loc[:, (0, 2):(1, 1)])
-        self.assert_eq(psdf.loc[:, (0, 2):0], pdf.loc[:, (0, 2):0])
-        self.assert_eq(psdf.loc[:, -1:2], pdf.loc[:, -1:2])
-
-    def test_loc2d_with_known_divisions(self):
-        pdf = pd.DataFrame(
-            np.random.randn(20, 5), index=list("abcdefghijklmnopqrst"), columns=list("ABCDE")
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc[["a"], "A"], pdf.loc[["a"], "A"])
-        self.assert_eq(psdf.loc[["a"], ["A"]], pdf.loc[["a"], ["A"]])
-        self.assert_eq(psdf.loc["a":"o", "A"], pdf.loc["a":"o", "A"])
-        self.assert_eq(psdf.loc["a":"o", ["A"]], pdf.loc["a":"o", ["A"]])
-        self.assert_eq(psdf.loc[["n"], ["A"]], pdf.loc[["n"], ["A"]])
-        self.assert_eq(psdf.loc[["a", "c", "n"], ["A"]], pdf.loc[["a", "c", "n"], ["A"]])
-        # TODO?: self.assert_eq(psdf.loc[['t', 'b'], ['A']], pdf.loc[['t', 'b'], ['A']])
-        # TODO?: self.assert_eq(psdf.loc[['r', 'r', 'c', 'g', 'h'], ['A']],
-        # TODO?:                pdf.loc[['r', 'r', 'c', 'g', 'h'], ['A']])
-
-    @unittest.skip("TODO: should handle duplicated columns properly")
-    def test_loc2d_duplicated_columns(self):
-        pdf = pd.DataFrame(
-            np.random.randn(20, 5), index=list("abcdefghijklmnopqrst"), columns=list("AABCD")
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # TODO?: self.assert_eq(psdf.loc[['a'], 'A'], pdf.loc[['a'], 'A'])
-        # TODO?: self.assert_eq(psdf.loc[['a'], ['A']], pdf.loc[['a'], ['A']])
-        self.assert_eq(psdf.loc[["j"], "B"], pdf.loc[["j"], "B"])
-        self.assert_eq(psdf.loc[["j"], ["B"]], pdf.loc[["j"], ["B"]])
-
-        # TODO?: self.assert_eq(psdf.loc['a':'o', 'A'], pdf.loc['a':'o', 'A'])
-        # TODO?: self.assert_eq(psdf.loc['a':'o', ['A']], pdf.loc['a':'o', ['A']])
-        self.assert_eq(psdf.loc["j":"q", "B"], pdf.loc["j":"q", "B"])
-        self.assert_eq(psdf.loc["j":"q", ["B"]], pdf.loc["j":"q", ["B"]])
-
-        # TODO?: self.assert_eq(psdf.loc['a':'o', 'B':'D'], pdf.loc['a':'o', 'B':'D'])
-        # TODO?: self.assert_eq(psdf.loc['a':'o', 'B':'D'], pdf.loc['a':'o', 'B':'D'])
-        # TODO?: self.assert_eq(psdf.loc['j':'q', 'B':'A'], pdf.loc['j':'q', 'B':'A'])
-        # TODO?: self.assert_eq(psdf.loc['j':'q', 'B':'A'], pdf.loc['j':'q', 'B':'A'])
-
-        self.assert_eq(psdf.loc[psdf.B > 0, "B"], pdf.loc[pdf.B > 0, "B"])
-        # TODO?: self.assert_eq(psdf.loc[psdf.B > 0, ['A', 'C']], pdf.loc[pdf.B > 0, ['A', 'C']])
-
-    def test_getitem(self):
-        pdf = pd.DataFrame(
-            {
-                "A": [1, 2, 3, 4, 5, 6, 7, 8, 9],
-                "B": [9, 8, 7, 6, 5, 4, 3, 2, 1],
-                "C": [True, False, True] * 3,
-            },
-            columns=list("ABC"),
-        )
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf["A"], pdf["A"])
-
-        self.assert_eq(psdf[["A", "B"]], pdf[["A", "B"]])
-
-        self.assert_eq(psdf[psdf.C], pdf[pdf.C])
-
-        self.assertRaises(KeyError, lambda: psdf["X"])
-        self.assertRaises(KeyError, lambda: psdf[["A", "X"]])
-        self.assertRaises(AttributeError, lambda: psdf.X)
-
-        # not str/unicode
-        # TODO?: pdf = pd.DataFrame(np.random.randn(10, 5))
-        # TODO?: psdf = ps.from_pandas(pdf)
-        # TODO?: self.assert_eq(psdf[0], pdf[0])
-        # TODO?: self.assert_eq(psdf[[1, 2]], pdf[[1, 2]])
-
-        # TODO?: self.assertRaises(KeyError, lambda: pdf[8])
-        # TODO?: self.assertRaises(KeyError, lambda: pdf[[1, 8]])
-
-        # non-string column names
-        pdf = pd.DataFrame(
-            {
-                10: [1, 2, 3, 4, 5, 6, 7, 8, 9],
-                20: [9, 8, 7, 6, 5, 4, 3, 2, 1],
-                30: [True, False, True] * 3,
-            }
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf[10], pdf[10])
-        self.assert_eq(psdf[[10, 20]], pdf[[10, 20]])
-
-    def test_getitem_slice(self):
-        pdf = pd.DataFrame(
-            {
-                "A": [1, 2, 3, 4, 5, 6, 7, 8, 9],
-                "B": [9, 8, 7, 6, 5, 4, 3, 2, 1],
-                "C": [True, False, True] * 3,
-            },
-            index=list("abcdefghi"),
-        )
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf["a":"e"], pdf["a":"e"])
-        self.assert_eq(psdf["a":"b"], pdf["a":"b"])
-        self.assert_eq(psdf["f":], pdf["f":])
-
-    def test_loc_on_numpy_datetimes(self):
-        pdf = pd.DataFrame(
-            {"x": [1, 2, 3]}, index=list(map(np.datetime64, ["2014", "2015", "2016"]))
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc["2014":"2015"], pdf.loc["2014":"2015"])
-
-    def test_loc_on_pandas_datetimes(self):
-        pdf = pd.DataFrame(
-            {"x": [1, 2, 3]}, index=list(map(pd.Timestamp, ["2014", "2015", "2016"]))
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.loc["2014":"2015"], pdf.loc["2014":"2015"])
-
-    @unittest.skip("TODO?: the behavior of slice for datetime")
-    def test_loc_datetime_no_freq(self):
-        datetime_index = pd.date_range("2016-01-01", "2016-01-31", freq="12h")
-        datetime_index.freq = None  # FORGET FREQUENCY
-        pdf = pd.DataFrame({"num": range(len(datetime_index))}, index=datetime_index)
-        psdf = ps.from_pandas(pdf)
-
-        slice_ = slice("2016-01-03", "2016-01-05")
-        result = psdf.loc[slice_, :]
-        expected = pdf.loc[slice_, :]
-        self.assert_eq(result, expected)
-
-    @unittest.skip("TODO?: the behavior of slice for datetime")
-    def test_loc_timestamp_str(self):
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.date_range("2011-01-01", freq="H", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # partial string slice
-        # TODO?: self.assert_eq(pdf.loc['2011-01-02'],
-        # TODO?:                psdf.loc['2011-01-02'])
-        self.assert_eq(pdf.loc["2011-01-02":"2011-01-05"], psdf.loc["2011-01-02":"2011-01-05"])
-
-        # series
-        # TODO?: self.assert_eq(pdf.A.loc['2011-01-02'],
-        # TODO?:                psdf.A.loc['2011-01-02'])
-        self.assert_eq(pdf.A.loc["2011-01-02":"2011-01-05"], psdf.A.loc["2011-01-02":"2011-01-05"])
-
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.date_range("2011-01-01", freq="M", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-        # TODO?: self.assert_eq(pdf.loc['2011-01'], psdf.loc['2011-01'])
-        # TODO?: self.assert_eq(pdf.loc['2011'], psdf.loc['2011'])
-
-        self.assert_eq(pdf.loc["2011-01":"2012-05"], psdf.loc["2011-01":"2012-05"])
-        self.assert_eq(pdf.loc["2011":"2015"], psdf.loc["2011":"2015"])
-
-        # series
-        # TODO?: self.assert_eq(pdf.B.loc['2011-01'], psdf.B.loc['2011-01'])
-        # TODO?: self.assert_eq(pdf.B.loc['2011'], psdf.B.loc['2011'])
-
-        self.assert_eq(pdf.B.loc["2011-01":"2012-05"], psdf.B.loc["2011-01":"2012-05"])
-        self.assert_eq(pdf.B.loc["2011":"2015"], psdf.B.loc["2011":"2015"])
-
-    @unittest.skip("TODO?: the behavior of slice for datetime")
-    def test_getitem_timestamp_str(self):
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.date_range("2011-01-01", freq="H", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # partial string slice
-        # TODO?: self.assert_eq(pdf['2011-01-02'],
-        # TODO?:                psdf['2011-01-02'])
-        self.assert_eq(pdf["2011-01-02":"2011-01-05"], psdf["2011-01-02":"2011-01-05"])
-
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.date_range("2011-01-01", freq="M", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # TODO?: self.assert_eq(pdf['2011-01'], psdf['2011-01'])
-        # TODO?: self.assert_eq(pdf['2011'], psdf['2011'])
-
-        self.assert_eq(pdf["2011-01":"2012-05"], psdf["2011-01":"2012-05"])
-        self.assert_eq(pdf["2011":"2015"], psdf["2011":"2015"])
-
-    @unittest.skip("TODO?: period index can't convert to DataFrame correctly")
-    def test_getitem_period_str(self):
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.period_range("2011-01-01", freq="H", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # partial string slice
-        # TODO?: self.assert_eq(pdf['2011-01-02'],
-        # TODO?:                psdf['2011-01-02'])
-        self.assert_eq(pdf["2011-01-02":"2011-01-05"], psdf["2011-01-02":"2011-01-05"])
-
-        pdf = pd.DataFrame(
-            {"A": np.random.randn(100), "B": np.random.randn(100)},
-            index=pd.period_range("2011-01-01", freq="M", periods=100),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        # TODO?: self.assert_eq(pdf['2011-01'], psdf['2011-01'])
-        # TODO?: self.assert_eq(pdf['2011'], psdf['2011'])
-
-        self.assert_eq(pdf["2011-01":"2012-05"], psdf["2011-01":"2012-05"])
-        self.assert_eq(pdf["2011":"2015"], psdf["2011":"2015"])
-
-    def test_iloc(self):
-        pdf = pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(psdf.iloc[0, 0], pdf.iloc[0, 0])
-        for indexer in [0, [0], [0, 1], [1, 0], [False, True, True], slice(0, 1)]:
-            self.assert_eq(psdf.iloc[:, indexer], pdf.iloc[:, indexer])
-            self.assert_eq(psdf.iloc[:1, indexer], pdf.iloc[:1, indexer])
-            self.assert_eq(psdf.iloc[:-1, indexer], pdf.iloc[:-1, indexer])
-            # self.assert_eq(psdf.iloc[psdf.index == 2, indexer], pdf.iloc[pdf.index == 2, indexer])
-
-    def test_iloc_multiindex_columns(self):
-        arrays = [np.array(["bar", "bar", "baz", "baz"]), np.array(["one", "two", "one", "two"])]
-
-        pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
-        psdf = ps.from_pandas(pdf)
-
-        for indexer in [0, [0], [0, 1], [1, 0], [False, True, True, True], slice(0, 1)]:
-            self.assert_eq(psdf.iloc[:, indexer], pdf.iloc[:, indexer])
-            self.assert_eq(psdf.iloc[:1, indexer], pdf.iloc[:1, indexer])
-            self.assert_eq(psdf.iloc[:-1, indexer], pdf.iloc[:-1, indexer])
-            # self.assert_eq(psdf.iloc[psdf.index == "B", indexer],
-            #                pdf.iloc[pdf.index == "B", indexer])
-
-    def test_iloc_series(self):
-        pser = pd.Series([1, 2, 3])
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(psser.iloc[0], pser.iloc[0])
-        self.assert_eq(psser.iloc[:], pser.iloc[:])
-        self.assert_eq(psser.iloc[:1], pser.iloc[:1])
-        self.assert_eq(psser.iloc[:-1], pser.iloc[:-1])
-
-        self.assert_eq((psser + 1).iloc[0], (pser + 1).iloc[0])
-        self.assert_eq((psser + 1).iloc[:], (pser + 1).iloc[:])
-        self.assert_eq((psser + 1).iloc[:1], (pser + 1).iloc[:1])
-        self.assert_eq((psser + 1).iloc[:-1], (pser + 1).iloc[:-1])
-
-    def test_iloc_slice_rows_sel(self):
-        pdf = pd.DataFrame({"A": [1, 2] * 5, "B": [3, 4] * 5, "C": [5, 6] * 5})
-        psdf = ps.from_pandas(pdf)
-
-        for rows_sel in [
-            slice(None),
-            slice(0, 1),
-            slice(1, 2),
-            slice(-3, None),
-            slice(None, -3),
-            slice(None, 0),
-            slice(None, None, 3),
-            slice(3, 8, 2),
-            slice(None, None, -2),
-            slice(8, 3, -2),
-            slice(8, None, -2),
-            slice(None, 3, -2),
-        ]:
-            with self.subTest(rows_sel=rows_sel):
-                self.assert_eq(psdf.iloc[rows_sel].sort_index(), pdf.iloc[rows_sel].sort_index())
-                self.assert_eq(
-                    psdf.A.iloc[rows_sel].sort_index(), pdf.A.iloc[rows_sel].sort_index()
-                )
-                self.assert_eq(
-                    (psdf.A + 1).iloc[rows_sel].sort_index(),
-                    (pdf.A + 1).iloc[rows_sel].sort_index(),
-                )
-
-    def test_iloc_iterable_rows_sel(self):
-        pdf = pd.DataFrame({"A": [1, 2] * 5, "B": [3, 4] * 5, "C": [5, 6] * 5})
-        psdf = ps.from_pandas(pdf)
-
-        for rows_sel in [
-            [],
-            np.array([0, 1]),
-            [1, 2],
-            np.array([-3]),
-            [3],
-            np.array([-2]),
-            [8, 3, -5],
-        ]:
-            with self.subTest(rows_sel=rows_sel):
-                self.assert_eq(psdf.iloc[rows_sel].sort_index(), pdf.iloc[rows_sel].sort_index())
-                self.assert_eq(
-                    psdf.A.iloc[rows_sel].sort_index(), pdf.A.iloc[rows_sel].sort_index()
-                )
-                self.assert_eq(
-                    (psdf.A + 1).iloc[rows_sel].sort_index(),
-                    (pdf.A + 1).iloc[rows_sel].sort_index(),
-                )
-
-            with self.subTest(rows_sel=rows_sel):
-                self.assert_eq(
-                    psdf.iloc[rows_sel, :].sort_index(), pdf.iloc[rows_sel, :].sort_index()
-                )
-
-            with self.subTest(rows_sel=rows_sel):
-                self.assert_eq(
-                    psdf.iloc[rows_sel, :1].sort_index(), pdf.iloc[rows_sel, :1].sort_index()
-                )
-
-    def test_frame_loc_setitem(self):
-        pdf = pd.DataFrame(
-            [[1, 2], [4, 5], [7, 8]],
-            index=["cobra", "viper", "sidewinder"],
-            columns=["max_speed", "shield"],
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pser1 = pdf.max_speed
-        pser2 = pdf.shield
-        psser1 = psdf.max_speed
-        psser2 = psdf.shield
-
-        pdf.loc[["viper", "sidewinder"], ["shield", "max_speed"]] = 10
-        psdf.loc[["viper", "sidewinder"], ["shield", "max_speed"]] = 10
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc[["viper", "sidewinder"], "shield"] = 50
-        psdf.loc[["viper", "sidewinder"], "shield"] = 50
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc["cobra", "max_speed"] = 30
-        psdf.loc["cobra", "max_speed"] = 30
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc[pdf.max_speed < 5, "max_speed"] = -pdf.max_speed
-        psdf.loc[psdf.max_speed < 5, "max_speed"] = -psdf.max_speed
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc[pdf.max_speed < 2, "max_speed"] = -pdf.max_speed
-        psdf.loc[psdf.max_speed < 2, "max_speed"] = -psdf.max_speed
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc[:, "min_speed"] = 0
-        psdf.loc[:, "min_speed"] = 0
-        self.assert_eq(psdf, pdf, almost=True)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        with self.assertRaisesRegex(ValueError, "Incompatible indexer with Series"):
-            psdf.loc["cobra", "max_speed"] = -psdf.max_speed
-        with self.assertRaisesRegex(ValueError, "shape mismatch"):
-            psdf.loc[:, ["shield", "max_speed"]] = -psdf.max_speed
-        with self.assertRaisesRegex(ValueError, "Only a dataframe with one column can be assigned"):
-            psdf.loc[:, "max_speed"] = psdf
-
-        # multi-index columns
-        columns = pd.MultiIndex.from_tuples(
-            [("x", "max_speed"), ("x", "shield"), ("y", "min_speed")]
-        )
-        pdf.columns = columns
-        psdf.columns = columns
-
-        pdf.loc[:, ("y", "shield")] = -pdf[("x", "shield")]
-        psdf.loc[:, ("y", "shield")] = -psdf[("x", "shield")]
-        self.assert_eq(psdf, pdf, almost=True)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        pdf.loc[:, "z"] = 100
-        psdf.loc[:, "z"] = 100
-        self.assert_eq(psdf, pdf, almost=True)
-        self.assert_eq(psser1, pser1)
-        self.assert_eq(psser2, pser2)
-
-        with self.assertRaisesRegex(KeyError, "Key length \\(3\\) exceeds index depth \\(2\\)"):
-            psdf.loc[:, [("x", "max_speed", "foo")]] = -psdf[("x", "shield")]
-
-        pdf = pd.DataFrame(
-            [[1], [4], [7]], index=["cobra", "viper", "sidewinder"], columns=["max_speed"]
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pdf.loc[:, "max_speed"] = pdf
-        psdf.loc[:, "max_speed"] = psdf
-        self.assert_eq(psdf, pdf)
-
-    def test_frame_iloc_setitem(self):
-        pdf = pd.DataFrame(
-            [[1, 2], [4, 5], [7, 8]],
-            index=["cobra", "viper", "sidewinder"],
-            columns=["max_speed", "shield"],
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pdf.iloc[[1, 2], [1, 0]] = 10
-        psdf.iloc[[1, 2], [1, 0]] = 10
-        self.assert_eq(psdf, pdf)
-
-        pdf.iloc[0, 1] = 50
-        psdf.iloc[0, 1] = 50
-        self.assert_eq(psdf, pdf)
-
-        with self.assertRaisesRegex(ValueError, "setting an array element with a sequence."):
-            psdf.iloc[0, 0] = -psdf.max_speed
-        with self.assertRaisesRegex(ValueError, "shape mismatch"):
-            psdf.iloc[:, [1, 0]] = -psdf.max_speed
-        with self.assertRaisesRegex(ValueError, "Only a dataframe with one column can be assigned"):
-            psdf.iloc[:, 0] = psdf
-
-        pdf = pd.DataFrame(
-            [[1], [4], [7]], index=["cobra", "viper", "sidewinder"], columns=["max_speed"]
-        )
-        psdf = ps.from_pandas(pdf)
-
-        pdf.iloc[:, 0] = pdf
-        psdf.iloc[:, 0] = psdf
-        self.assert_eq(psdf, pdf)
-
-    def test_series_loc_setitem(self):
-        pdf = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]}, index=["cobra", "viper", "sidewinder"])
-        psdf = ps.from_pandas(pdf)
-
-        pser = pdf.x
-        psery = pdf.y
-        psser = psdf.x
-        pssery = psdf.y
-
-        pser.loc[pser % 2 == 1] = -pser
-        psser.loc[psser % 2 == 1] = -psser
-        self.assert_eq(psser, pser)
-        self.assert_eq(psdf, pdf)
-        self.assert_eq(pssery, psery)
-
-        for key, value in [
-            (["viper", "sidewinder"], 10),
-            ("viper", 50),
-            (slice(None), 10),
-            (slice(None, "viper"), 20),
-            (slice("viper", None), 30),
-        ]:
-            with self.subTest(key=key, value=value):
-                pser.loc[key] = value
-                psser.loc[key] = value
-                self.assert_eq(psser, pser)
-                self.assert_eq(psdf, pdf)
-                self.assert_eq(pssery, psery)
-
-        with self.assertRaises(ValueError):
-            psser.loc["viper"] = -psser
-
-        # multiindex
-        pser = pd.Series(
-            [1, 2, 3],
-            index=pd.MultiIndex.from_tuples([("x", "cobra"), ("x", "viper"), ("y", "sidewinder")]),
-        )
-        psser = ps.from_pandas(pser)
-
-        pser.loc["x"] = pser * 10
-        psser.loc["x"] = psser * 10
-        self.assert_eq(psser, pser)
-
-        pser.loc["y"] = pser * 10
-        psser.loc["y"] = psser * 10
-        self.assert_eq(psser, pser)
-
-    def test_series_iloc_setitem(self):
-        pdf = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]}, index=["cobra", "viper", "sidewinder"])
-        psdf = ps.from_pandas(pdf)
-
-        pser = pdf.x
-        psery = pdf.y
-        psser = psdf.x
-        pssery = psdf.y
-
-        piloc = pser.iloc
-        kiloc = psser.iloc
-
-        pser1 = pser + 1
-        psser1 = psser + 1
-
-        for key, value in [
-            ([1, 2], 10),
-            (1, 50),
-            (slice(None), 10),
-            (slice(None, 1), 20),
-            (slice(1, None), 30),
-        ]:
-            with self.subTest(key=key, value=value):
-                pser.iloc[key] = value
-                psser.iloc[key] = value
-                self.assert_eq(psser, pser)
-                self.assert_eq(psdf, pdf)
-                self.assert_eq(pssery, psery)
-
-                piloc[key] = -value
-                kiloc[key] = -value
-                self.assert_eq(psser, pser)
-                self.assert_eq(psdf, pdf)
-                self.assert_eq(pssery, psery)
-
-                pser1.iloc[key] = value
-                psser1.iloc[key] = value
-                self.assert_eq(psser1, pser1)
-                self.assert_eq(psdf, pdf)
-                self.assert_eq(pssery, psery)
-
-        with self.assertRaises(ValueError):
-            psser.iloc[1] = -psser
-
-        pser = pd.Index([1, 2, 3]).to_series()
-        psser = ps.Index([1, 2, 3]).to_series()
-
-        pser1 = pser + 1
-        psser1 = psser + 1
-
-        pser.iloc[0] = 10
-        psser.iloc[0] = 10
-        self.assert_eq(psser, pser)
-
-        pser1.iloc[0] = 20
-        psser1.iloc[0] = 20
-        self.assert_eq(psser1, pser1)
-
-        pdf = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
-        psdf = ps.from_pandas(pdf)
-
-        pser = pdf.a
-        psser = psdf.a
-
-        pser.iloc[[0, 1, 2]] = -pdf.b
-        psser.iloc[[0, 1, 2]] = -psdf.b
-        self.assert_eq(psser, pser)
-        self.assert_eq(psdf, pdf)
-
-        with self.assertRaisesRegex(ValueError, "setting an array element with a sequence."):
-            psser.iloc[1] = psdf[["b"]]
-
-    def test_iloc_raises(self):
-        pdf = pd.DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
-        psdf = ps.from_pandas(pdf)
-
-        with self.assertRaisesRegex(SparkPandasIndexingError, "Only accepts pairs of candidates"):
-            psdf.iloc[[0, 1], [0, 1], [1, 2]]
-
-        with self.assertRaisesRegex(SparkPandasIndexingError, "Too many indexers"):
-            psdf.A.iloc[[0, 1], [0, 1]]
-
-        with self.assertRaisesRegex(TypeError, "cannot do slice indexing with these indexers"):
-            psdf.iloc[:"b", :]
-
-        with self.assertRaisesRegex(TypeError, "cannot do slice indexing with these indexers"):
-            psdf.iloc[:, :"b"]
-
-        with self.assertRaisesRegex(TypeError, "cannot perform reduce with flexible type"):
-            psdf.iloc[:, ["A"]]
-
-        with self.assertRaisesRegex(ValueError, "Location based indexing can only have"):
-            psdf.iloc[:, "A"]
-
-        with self.assertRaisesRegex(IndexError, "out of range"):
-            psdf.iloc[:, [5, 6]]
-
-    def test_index_operator_datetime(self):
-        dates = pd.date_range("20130101", periods=6)
-        pdf = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD"))
-        psdf = ps.from_pandas(pdf)
-
-        # Positional iloc search
-        self.assert_eq(psdf[:4], pdf[:4], almost=True)
-        self.assert_eq(psdf[:3], pdf[:3], almost=True)
-        self.assert_eq(psdf[3:], pdf[3:], almost=True)
-        self.assert_eq(psdf[2:], pdf[2:], almost=True)
-        self.assert_eq(psdf[2:3], pdf[2:3], almost=True)
-        self.assert_eq(psdf[2:-1], pdf[2:-1], almost=True)
-        self.assert_eq(psdf[10:3], pdf[10:3], almost=True)
-
-        # Index loc search
-        self.assert_eq(psdf.A[4], pdf.A[4])
-        self.assert_eq(psdf.A[3], pdf.A[3])
-
-        # Positional iloc search
-        self.assert_eq(psdf.A[:4], pdf.A[:4], almost=True)
-        self.assert_eq(psdf.A[:3], pdf.A[:3], almost=True)
-        self.assert_eq(psdf.A[3:], pdf.A[3:], almost=True)
-        self.assert_eq(psdf.A[2:], pdf.A[2:], almost=True)
-        self.assert_eq(psdf.A[2:3], pdf.A[2:3], almost=True)
-        self.assert_eq(psdf.A[2:-1], pdf.A[2:-1], almost=True)
-        self.assert_eq(psdf.A[10:3], pdf.A[10:3], almost=True)
-
-        dt1 = datetime.datetime.strptime("2013-01-02", "%Y-%m-%d")
-        dt2 = datetime.datetime.strptime("2013-01-04", "%Y-%m-%d")
-
-        # Index loc search
-        self.assert_eq(psdf[:dt2], pdf[:dt2], almost=True)
-        self.assert_eq(psdf[dt1:], pdf[dt1:], almost=True)
-        self.assert_eq(psdf[dt1:dt2], pdf[dt1:dt2], almost=True)
-        self.assert_eq(psdf.A[dt2], pdf.A[dt2], almost=True)
-        self.assert_eq(psdf.A[:dt2], pdf.A[:dt2], almost=True)
-        self.assert_eq(psdf.A[dt1:], pdf.A[dt1:], almost=True)
-        self.assert_eq(psdf.A[dt1:dt2], pdf.A[dt1:dt2], almost=True)
-
-    def test_index_operator_int(self):
-        pdf = pd.DataFrame(np.random.randn(6, 4), index=[1, 3, 5, 7, 9, 11], columns=list("ABCD"))
-        psdf = ps.from_pandas(pdf)
-
-        # Positional iloc search
-        self.assert_eq(psdf[:4], pdf[:4])
-        self.assert_eq(psdf[:3], pdf[:3])
-        self.assert_eq(psdf[3:], pdf[3:])
-        self.assert_eq(psdf[2:], pdf[2:])
-        self.assert_eq(psdf[2:3], pdf[2:3])
-        self.assert_eq(psdf[2:-1], pdf[2:-1])
-        self.assert_eq(psdf[10:3], pdf[10:3])
-
-        # Index loc search
-        self.assert_eq(psdf.A[5], pdf.A[5])
-        self.assert_eq(psdf.A[3], pdf.A[3])
-        with self.assertRaisesRegex(
-            NotImplementedError, "Duplicated row selection is not currently supported"
-        ):
-            psdf.iloc[[1, 1]]
-
-
-class BasicIndexingTests(BasicIndexingTestsMixin, ComparisonTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.test_indexing 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)