wip

Author: MarcoGorelli

pandas/tests/series/indexing/test_setitem.py

@@ -596,11 +596,14 @@ def test_setitem_enlarge_with_na(
     ):
         # GH#32346
         ser = Series([1, 2], dtype=dtype)
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        if warn:
+            with pytest.raises(TypeError, match="Invalid value"):
+                ser[indexer] = na
+        else:
             ser[indexer] = na
-        expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
-        expected = Series(expected_values, dtype=target_dtype)
-        tm.assert_series_equal(ser, expected)
+            expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na]
+            expected = Series(expected_values, dtype=target_dtype)
+            tm.assert_series_equal(ser, expected)
 
     def test_setitem_enlargement_object_none(self, nulls_fixture, using_infer_string):
         # GH#48665
@@ -694,14 +697,8 @@ def test_setitem_non_bool_into_bool(self, val, indexer_sli, unique):
         if not unique:
             ser.index = [1, 1]
 
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             indexer_sli(ser)[1] = val
-        assert type(ser.iloc[1]) == type(val)
-
-        expected = Series([True, val], dtype=object, index=ser.index)
-        if not unique and indexer_sli is not tm.iloc:
-            expected = Series([val, val], dtype=object, index=[1, 1])
-        tm.assert_series_equal(ser, expected)
 
     def test_setitem_boolean_array_into_npbool(self):
         # GH#45462
@@ -712,10 +709,8 @@ def test_setitem_boolean_array_into_npbool(self):
         ser[:2] = arr[:2]  # no NAs -> can set inplace
         assert ser._values is values
 
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             ser[1:] = arr[1:]  # has an NA -> cast to boolean dtype
-        expected = Series(arr)
-        tm.assert_series_equal(ser, expected)
 
 
 class SetitemCastingEquivalents:
@@ -763,36 +758,36 @@ def test_int_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace):
         if not isinstance(key, int):
             pytest.skip("Not relevant for int key")
 
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
 
         if indexer_sli is tm.loc:
-            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            with pytest.raises(TypeError, match="Invalid value"):
                 self.check_indexer(obj, key, expected, val, tm.at, is_inplace)
         elif indexer_sli is tm.iloc:
-            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            with pytest.raises(TypeError, match="Invalid value"):
                 self.check_indexer(obj, key, expected, val, tm.iat, is_inplace)
 
         rng = range(key, key + 1)
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, rng, expected, val, indexer_sli, is_inplace)
 
         if indexer_sli is not tm.loc:
             # Note: no .loc because that handles slice edges differently
             slc = slice(key, key + 1)
-            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            with pytest.raises(TypeError, match="Invalid value"):
                 self.check_indexer(obj, slc, expected, val, indexer_sli, is_inplace)
 
         ilkey = [key]
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
 
         indkey = np.array(ilkey)
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
 
         genkey = (x for x in [key])
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
 
     def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace):
@@ -801,19 +796,19 @@ def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace)
 
         if indexer_sli is not tm.loc:
             # Note: no .loc because that handles slice edges differently
-            with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            with pytest.raises(TypeError, match="Invalid value"):
                 self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace)
 
         ilkey = list(range(len(obj)))[key]
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace)
 
         indkey = np.array(ilkey)
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace)
 
         genkey = (x for x in indkey)
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace)
 
     def test_mask_key(self, obj, key, expected, warn, val, indexer_sli):
@@ -829,7 +824,7 @@ def test_mask_key(self, obj, key, expected, warn, val, indexer_sli):
                 indexer_sli(obj)[mask] = val
             return
 
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             indexer_sli(obj)[mask] = val
         tm.assert_series_equal(obj, expected)
 
@@ -1185,11 +1180,8 @@ def test_setitem_example(self):
         obj = Series(idx)
         val = Interval(0.5, 1.5)
 
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             obj[0] = val
-        assert obj.dtype == "Interval[float64, right]"
 
     @pytest.fixture
     def obj(self):
@@ -1583,55 +1575,37 @@ def test_20643():
     # closed by GH#45121
     orig = Series([0, 1, 2], index=["a", "b", "c"])
 
-    expected = Series([0, 2.7, 2], index=["a", "b", "c"])
-
     ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.at["b"] = 2.7
-    tm.assert_series_equal(ser, expected)
 
-    ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.loc["b"] = 2.7
-    tm.assert_series_equal(ser, expected)
 
-    ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser["b"] = 2.7
-    tm.assert_series_equal(ser, expected)
 
     ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.iat[1] = 2.7
-    tm.assert_series_equal(ser, expected)
 
-    ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.iloc[1] = 2.7
-    tm.assert_series_equal(ser, expected)
 
     orig_df = orig.to_frame("A")
-    expected_df = expected.to_frame("A")
 
     df = orig_df.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         df.at["b", "A"] = 2.7
-    tm.assert_frame_equal(df, expected_df)
 
-    df = orig_df.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         df.loc["b", "A"] = 2.7
-    tm.assert_frame_equal(df, expected_df)
 
-    df = orig_df.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         df.iloc[1, 0] = 2.7
-    tm.assert_frame_equal(df, expected_df)
 
-    df = orig_df.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         df.iat[1, 0] = 2.7
-    tm.assert_frame_equal(df, expected_df)
 
 
 def test_20643_comment():
@@ -1653,35 +1627,23 @@ def test_15413():
     # fixed by GH#45121
     ser = Series([1, 2, 3])
 
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser[ser == 2] += 0.5
-    expected = Series([1, 2.5, 3])
-    tm.assert_series_equal(ser, expected)
 
-    ser = Series([1, 2, 3])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser[1] += 0.5
-    tm.assert_series_equal(ser, expected)
 
-    ser = Series([1, 2, 3])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.loc[1] += 0.5
-    tm.assert_series_equal(ser, expected)
 
-    ser = Series([1, 2, 3])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.iloc[1] += 0.5
-    tm.assert_series_equal(ser, expected)
 
-    ser = Series([1, 2, 3])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.iat[1] += 0.5
-    tm.assert_series_equal(ser, expected)
 
-    ser = Series([1, 2, 3])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser.at[1] += 0.5
-    tm.assert_series_equal(ser, expected)
 
 
 def test_32878_int_itemsize():

pandas/tests/series/methods/test_fillna.py

@@ -159,9 +159,8 @@ def test_fillna_consistency(self):
 
         # assignment
         ser2 = ser.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             ser2[1] = "foo"
-        tm.assert_series_equal(ser2, expected)
 
     def test_timedelta_fillna(self, frame_or_series, unit):
         # GH#3371