TST: Add tests for logical operators in pd.col Expression class

Add comprehensive tests for the new logical operators (__and__, __or__,
__xor__, __invert__) in the Expression class:

- test_col_logical_ops: Parametrized tests for &, |, ^, ~ operators
  with both column-to-column and column-to-scalar operations
- test_col_logical_ops_combined: Integration test demonstrating
  real-world usage in DataFrame.loc[] with combined conditions

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: majiayu000

pandas/tests/test_col.py

@@ -97,3 +97,93 @@ def mean(self):
         result = df.assign(b=pd.col("a").xyz.mean())
     expected = pd.DataFrame({"a": [1, 2, 3], "b": [2.0, 2.0, 2.0]})
     tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    ("expr", "expected_values", "expected_str"),
+    [
+        # __and__ and __rand__
+        # a = [True, False, True, False], b = [False, True, True, True]
+        # a & b = [False, False, True, False]
+        (
+            pd.col("a") & pd.col("b"),
+            [False, False, True, False],
+            "(col('a') & col('b'))",
+        ),
+        (
+            pd.col("a") & True,
+            [True, False, True, False],
+            "(col('a') & True)",
+        ),
+        # __or__ and __ror__
+        (
+            pd.col("a") | pd.col("b"),
+            [True, True, True, True],
+            "(col('a') | col('b'))",
+        ),
+        (
+            pd.col("a") | False,
+            [True, False, True, False],
+            "(col('a') | False)",
+        ),
+        # __xor__ and __rxor__
+        # a ^ b = [True, True, False, True]
+        (
+            pd.col("a") ^ pd.col("b"),
+            [True, True, False, True],
+            "(col('a') ^ col('b'))",
+        ),
+        (
+            pd.col("a") ^ True,
+            [False, True, False, True],
+            "(col('a') ^ True)",
+        ),
+        # __invert__
+        (
+            ~pd.col("a"),
+            [False, True, False, True],
+            "(~col('a'))",
+        ),
+    ],
+)
+def test_col_logical_ops(
+    expr: Expression, expected_values: list[object], expected_str: str
+) -> None:
+    df = pd.DataFrame({"a": [True, False, True, False], "b": [False, True, True, True]})
+    result = df.assign(c=expr)
+    expected = pd.DataFrame(
+        {
+            "a": [True, False, True, False],
+            "b": [False, True, True, True],
+            "c": expected_values,
+        }
+    )
+    tm.assert_frame_equal(result, expected)
+    assert str(expr) == expected_str
+
+
+def test_col_logical_ops_combined() -> None:
+    """Test combining multiple logical operators like in DataFrame.loc[]."""
+    df = pd.DataFrame(
+        {
+            "x": [1, 2, 3, 4, 5],
+            "y": [10, 20, 30, 40, 50],
+        }
+    )
+    # Test combining conditions with & operator
+    expr = (pd.col("x") > 2) & (pd.col("y") < 45)
+    result = df.loc[expr]
+    expected = df.loc[(df["x"] > 2) & (df["y"] < 45)]
+    tm.assert_frame_equal(result, expected)
+
+    # Test combining conditions with | operator
+    expr = (pd.col("x") == 1) | (pd.col("x") == 5)
+    result = df.loc[expr]
+    expected = df.loc[(df["x"] == 1) | (df["x"] == 5)]
+    tm.assert_frame_equal(result, expected)
+
+    # Test negation with ~
+    expr = ~(pd.col("x") > 3)
+    result = df.loc[expr]
+    expected = df.loc[~(df["x"] > 3)]
+    tm.assert_frame_equal(result, expected)