wip

Author: MarcoGorelli

pandas/tests/indexing/multiindex/test_setitem.py

@@ -213,13 +213,8 @@ def test_multiindex_assignment_single_dtype(self):
         tm.assert_series_equal(result, exp)
 
         # arr + 0.5 cannot be cast losslessly to int, so we upcast
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             df.loc[4, "c"] = arr + 0.5
-        result = df.loc[4, "c"]
-        exp = exp + 0.5
-        tm.assert_series_equal(result, exp)
 
         # scalar ok
         df.loc[4, "c"] = 10

pandas/tests/series/indexing/test_setitem.py

@@ -273,25 +273,16 @@ def test_setitem_mask_align_and_promote(self):
         mask = ts > 0
         left = ts.copy()
         right = ts[mask].copy().map(str)
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             left[mask] = right
-        expected = ts.map(lambda t: str(t) if t > 0 else t)
-        tm.assert_series_equal(left, expected)
 
     def test_setitem_mask_promote_strs(self):
         ser = Series([0, 1, 2, 0])
         mask = ser > 0
         ser2 = ser[mask].map(str)
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             ser[mask] = ser2
 
-        expected = Series([0, "1", "2", 0])
-        tm.assert_series_equal(ser, expected)
-
     def test_setitem_mask_promote(self):
         ser = Series([0, "foo", "bar", 0])
         mask = Series([False, True, True, False])
@@ -379,12 +370,8 @@ def test_setitem_with_bool_mask_and_values_matching_n_trues_in_length(self):
     def test_setitem_nan_with_bool(self):
         # GH 13034
         result = Series([True, False, True])
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             result[0] = np.nan
-        expected = Series([np.nan, False, True], dtype=object)
-        tm.assert_series_equal(result, expected)
 
     def test_setitem_mask_smallint_upcast(self):
         orig = Series([1, 2, 3], dtype="int8")
@@ -393,22 +380,16 @@ def test_setitem_mask_smallint_upcast(self):
         mask = np.array([True, False, True])
 
         ser = orig.copy()
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
+        with pytest.raises(TypeError, match="Invalid value"):
             ser[mask] = Series(alt)
-        expected = Series([999, 2, 1001])
-        tm.assert_series_equal(ser, expected)
 
-        ser2 = orig.copy()
         with tm.assert_produces_warning(
             FutureWarning, match="item of incompatible dtype"
         ):
-            ser2.mask(mask, alt, inplace=True)
-        tm.assert_series_equal(ser2, expected)
+            ser.mask(mask, alt, inplace=True)
 
-        ser3 = orig.copy()
-        res = ser3.where(~mask, Series(alt))
+        res = ser.where(~mask, Series(alt))
+        expected = Series([999, 2, 1001])
         tm.assert_series_equal(res, expected)
 
     def test_setitem_mask_smallint_no_upcast(self):
@@ -1651,10 +1632,8 @@ def test_32878_int_itemsize():
     arr = np.arange(5).astype("i4")
     ser = Series(arr)
     val = np.int64(np.iinfo(np.int64).max)
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser[0] = val
-    expected = Series([val, 1, 2, 3, 4], dtype=np.int64)
-    tm.assert_series_equal(ser, expected)
 
 
 def test_32878_complex_itemsize():
@@ -1664,20 +1643,15 @@ def test_32878_complex_itemsize():
     val = val.astype("c16")
 
     # GH#32878 used to coerce val to inf+0.000000e+00j
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         ser[0] = val
-    assert ser[0] == val
-    expected = Series([val, 1, 2, 3, 4], dtype="c16")
-    tm.assert_series_equal(ser, expected)
 
 
 def test_37692(indexer_al):
     # GH#37692
     ser = Series([1, 2, 3], index=["a", "b", "c"])
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+    with pytest.raises(TypeError, match="Invalid value"):
         indexer_al(ser)["b"] = "test"
-    expected = Series([1, "test", 3], index=["a", "b", "c"], dtype=object)
-    tm.assert_series_equal(ser, expected)
 
 
 def test_setitem_bool_int_float_consistency(indexer_sli):
@@ -1687,14 +1661,12 @@ def test_setitem_bool_int_float_consistency(indexer_sli):
     #  as the setitem can be done losslessly
     for dtype in [np.float64, np.int64]:
         ser = Series(0, index=range(3), dtype=dtype)
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             indexer_sli(ser)[0] = True
-        assert ser.dtype == object
 
         ser = Series(0, index=range(3), dtype=bool)
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+        with pytest.raises(TypeError, match="Invalid value"):
             ser[0] = dtype(1)
-        assert ser.dtype == object
 
     # 1.0 can be held losslessly, so no casting
     ser = Series(0, index=range(3), dtype=np.int64)