CLN/TST: parametrize some tests in tests.indexing.test_float

pandas/tests/frame/indexing/test_datetime.py

@@ -40,7 +40,7 @@ def test_set_reset(self):
         # set/reset
         df = DataFrame({"A": [0, 1, 2]}, index=idx)
         result = df.reset_index()
-        assert result["foo"].dtype, "M8[ns, US/Eastern"
+        assert result["foo"].dtype == "datetime64[ns, US/Eastern]"
 
         df = result.set_index("foo")
         tm.assert_index_equal(df.index, idx)

pandas/tests/indexing/test_floats.py

@@ -32,19 +32,7 @@ def check(self, result, original, indexer, getitem):
 
         tm.assert_almost_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "index_func",
-        [
-            tm.makeStringIndex,
-            tm.makeUnicodeIndex,
-            tm.makeCategoricalIndex,
-            tm.makeDateIndex,
-            tm.makeTimedeltaIndex,
-            tm.makePeriodIndex,
-            tm.makeIntIndex,
-            tm.makeRangeIndex,
-        ],
-    )
+    @pytest.mark.parametrize("index_func", tm.all_index_generator(5))
     def test_scalar_error(self, index_func):
 
         # GH 4892
@@ -54,7 +42,7 @@ def test_scalar_error(self, index_func):
         # but is specifically testing for the error
         # message
 
-        i = index_func(5)
+        i = index_func
 
         s = Series(np.arange(len(i)), index=i)
 
@@ -162,10 +150,9 @@ def test_scalar_non_numeric(self, index_func, klass):
             s2.loc[3.0] = 10
             assert s2.index.is_object()
 
-            for idxr in [lambda x: x]:
-                s2 = s.copy()
-                idxr(s2)[3.0] = 0
-                assert s2.index.is_object()
+            s2 = s.copy()
+            s2[3.0] = 0
+            assert s2.index.is_object()
 
     @pytest.mark.parametrize(
         "index_func",
@@ -250,12 +237,7 @@ def test_scalar_integer(self, index_func, klass):
 
         # integer index
         i = index_func(5)
-
-        if klass is Series:
-            # TODO: Should we be passing index=i here?
-            obj = Series(np.arange(len(i)))
-        else:
-            obj = DataFrame(np.random.randn(len(i), len(i)), index=i, columns=i)
+        obj = gen_obj(klass, i)
 
         # coerce to equal int
         for idxr, getitem in [(lambda x: x.loc, False), (lambda x: x, True)]:
@@ -313,7 +295,7 @@ def test_scalar_float(self, klass):
             result = idxr(s2)[indexer]
             self.check(result, s, 3, getitem)
 
-            # random integer is a KeyError
+            # random float is a KeyError
             with pytest.raises(KeyError, match=r"^3\.5$"):
                 idxr(s)[3.5]
 
@@ -429,15 +411,6 @@ def test_slice_integer(self):
                     indexer = slice(3, 5)
                 self.check(result, s, indexer, False)
 
-                # positional indexing
-                msg = (
-                    "cannot do slice indexing "
-                    fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
-                    "type float"
-                )
-                with pytest.raises(TypeError, match=msg):
-                    s[l]
-
             # getitem out-of-bounds
             for l in [slice(-6, 6), slice(-6.0, 6.0)]:
 
@@ -485,23 +458,6 @@ def test_slice_integer(self):
                 with pytest.raises(TypeError, match=msg):
                     s[l]
 
-            # setitem
-            for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
-
-                sc = s.copy()
-                sc.loc[l] = 0
-                result = sc.loc[l].values.ravel()
-                assert (result == 0).all()
-
-                # positional indexing
-                msg = (
-                    "cannot do slice indexing "
-                    fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
-                    "type float"
-                )
-                with pytest.raises(TypeError, match=msg):
-                    s[l] = 0
-
     @pytest.mark.parametrize("l", [slice(2, 4.0), slice(2.0, 4), slice(2.0, 4.0)])
     def test_integer_positional_indexing(self, l):
         """ make sure that we are raising on positional indexing
@@ -584,22 +540,34 @@ def test_slice_integer_frame_getitem(self, index_func):
             with pytest.raises(TypeError, match=msg):
                 s[l]
 
+    @pytest.mark.parametrize("l", [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)])
+    @pytest.mark.parametrize(
+        "index_func", [tm.makeIntIndex, tm.makeRangeIndex],
+    )
+    def test_float_slice_getitem_with_integer_index_raises(self, l, index_func):
+
+        # similar to above, but on the getitem dim (of a DataFrame)
+        index = index_func(5)
+
+        s = DataFrame(np.random.randn(5, 2), index=index)
+
         # setitem
-        for l in [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)]:
+        sc = s.copy()
+        sc.loc[l] = 0
+        result = sc.loc[l].values.ravel()
+        assert (result == 0).all()
 
-            sc = s.copy()
-            sc.loc[l] = 0
-            result = sc.loc[l].values.ravel()
-            assert (result == 0).all()
+        # positional indexing
+        msg = (
+            "cannot do slice indexing "
+            fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
+            "type float"
+        )
+        with pytest.raises(TypeError, match=msg):
+            s[l] = 0
 
-            # positional indexing
-            msg = (
-                "cannot do slice indexing "
-                fr"on {type(index).__name__} with these indexers \[(3|4)\.0\] of "
-                "type float"
-            )
-            with pytest.raises(TypeError, match=msg):
-                s[l] = 0
+        with pytest.raises(TypeError, match=msg):
+            s[l]
 
     @pytest.mark.parametrize("l", [slice(3.0, 4), slice(3, 4.0), slice(3.0, 4.0)])
     @pytest.mark.parametrize("klass", [Series, DataFrame])
@@ -614,10 +582,9 @@ def test_slice_float(self, l, klass):
 
             # getitem
             result = idxr(s)[l]
-            if isinstance(s, Series):
-                tm.assert_series_equal(result, expected)
-            else:
-                tm.assert_frame_equal(result, expected)
+            assert isinstance(result, type(s))
+            tm.assert_equal(result, expected)
+
             # setitem
             s2 = s.copy()
             idxr(s2)[l] = 0