test: better way to test inverted dunder methods

tests/safeds/data/tabular/containers/_cell/test_add.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell + value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
-        assert_cell_operation_works(value1, lambda cell: value2 + cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 + cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell.add(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_and.py

@@ -33,7 +33,7 @@ def test_dunder_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell & value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: Any, value2: bool, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 & cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 & cell, expected)
 
     def test_named_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.and_(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_div.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell / value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
-        assert_cell_operation_works(value1, lambda cell: value2 / cell, 1 / expected)
+        assert_cell_operation_works(value2, lambda cell: value1 / cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell.div(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_eq.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell == value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 == cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 == cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.eq(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_floordiv.py

@@ -3,39 +3,24 @@
 from tests.helpers import assert_cell_operation_works
 
 
+@pytest.mark.parametrize(
+    ("value1", "value2", "expected"),
+    [
+        (3, 2, 1),
+        (3, 1.6, 1),
+        (1.5, 3, 0),
+        (1.5, 1.4, 1),
+    ],
+    ids=[
+        "int - int",
+        "int - float",
+        "float - int",
+        "float - float",
+    ],
+)
 class TestShouldComputeDivision:
-    @pytest.mark.parametrize(
-        ("value1", "value2", "expected"),
-        [
-            (3, 2, 1),
-            (3, 1.6, 1),
-            (1.5, 3, 0),
-            (1.5, 1.4, 1),
-        ],
-        ids=[
-            "int - int",
-            "int - float",
-            "float - int",
-            "float - float",
-        ],
-    )
     def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell // value2, expected)
 
-    @pytest.mark.parametrize(
-        ("value1", "value2", "expected_inverted"),
-        [
-            (3, 2, 0),
-            (3, 1.6, 0),
-            (1.5, 3, 2),
-            (1.5, 1.4, 0),
-        ],
-        ids=[
-            "int - int",
-            "int - float",
-            "float - int",
-            "float - float",
-        ],
-    )
-    def test_dunder_method_inverted_order(self, value1: float, value2: float, expected_inverted: float):
-        assert_cell_operation_works(value1, lambda cell: value2 // cell, expected_inverted)
+    def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
+        assert_cell_operation_works(value2, lambda cell: value1 // cell, expected)

tests/safeds/data/tabular/containers/_cell/test_ge.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell >= value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 <= cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 >= cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.ge(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_gt.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell > value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 < cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 > cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.gt(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_le.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell <= value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 >= cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 <= cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.le(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_lt.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell < value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 > cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 < cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.lt(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_mod.py

@@ -22,24 +22,8 @@ class TestShouldComputeModulus:
     def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell % value2, expected)
 
+    def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
+        assert_cell_operation_works(value2, lambda cell: value1 % cell, expected)
+
     def test_named_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell.mod(value2), expected)
-
-
-@pytest.mark.parametrize(
-    ("value1", "value2", "expected_inverted"),
-    [
-        (3, 3, 0),
-        (3, 1.5, 1.5),
-        (1.5, 3, 0.0),
-        (1.5, 1.5, 0.0),
-    ],
-    ids=[
-        "int - int",
-        "int - float",
-        "float - int",
-        "float - float",
-    ],
-)
-def test_dunder_method_inverted_order(value1: float, value2: float, expected_inverted: float):
-    assert_cell_operation_works(value1, lambda cell: value2 % cell, expected_inverted)

tests/safeds/data/tabular/containers/_cell/test_mul.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell * value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
-        assert_cell_operation_works(value1, lambda cell: value2 * cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 * cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell.mul(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_or.py

@@ -33,7 +33,7 @@ def test_dunder_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell | value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: Any, value2: bool, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 | cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 | cell, expected)
 
     def test_named_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.or_(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_sub.py

@@ -23,7 +23,7 @@ def test_dunder_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell - value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: float, value2: float, expected: float):
-        assert_cell_operation_works(value1, lambda cell: value2 - cell, -expected)
+        assert_cell_operation_works(value2, lambda cell: value1 - cell, expected)
 
     def test_named_method(self, value1: float, value2: float, expected: float):
         assert_cell_operation_works(value1, lambda cell: cell.sub(value2), expected)

tests/safeds/data/tabular/containers/_cell/test_xor.py

@@ -33,7 +33,7 @@ def test_dunder_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell ^ value2, expected)
 
     def test_dunder_method_inverted_order(self, value1: Any, value2: bool, expected: bool):
-        assert_cell_operation_works(value1, lambda cell: value2 ^ cell, expected)
+        assert_cell_operation_works(value2, lambda cell: value1 ^ cell, expected)
 
     def test_named_method(self, value1: Any, value2: bool, expected: bool):
         assert_cell_operation_works(value1, lambda cell: cell.xor(value2), expected)