test: improve structure of table tests

tests/safeds/data/tabular/containers/_table/test_add_column.py

@@ -1,33 +1,36 @@
 import pytest
 from safeds.data.tabular.containers import Column, Table
 from safeds.data.tabular.exceptions import ColumnSizeError, DuplicateColumnNameError
-from safeds.data.tabular.typing import ColumnType, Integer, String
 
 
 @pytest.mark.parametrize(
-    ("column", "col_type"),
+    ("table1", "column", "expected"),
     [
-        (Column("col3", ["a", "b", "c"]), String()),
-        (Column("col3", [0, -1, -2]), Integer()),
+        (
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+            Column("col3", ["a", "b", "c"]),
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4], "col3": ["a", "b", "c"]}),
+        ),
+        (
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+            Column("col3", [0, -1, -2]),
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4], "col3": [0, -1, -2]}),
+        ),
     ],
+    ids=["String", "Integer"],
 )
-def test_add_column_valid(column: Column, col_type: ColumnType) -> None:
-    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
+def test_should_add_column(table1: Table, column: Column, expected: Table) -> None:
     table1 = table1.add_column(column)
-    assert table1.number_of_columns == 3
-    assert table1.get_column("col3") == column
-    assert isinstance(table1.schema.get_column_type("col1"), Integer)
-    assert isinstance(table1.schema.get_column_type("col2"), Integer)
-    assert isinstance(table1.schema.get_column_type("col3"), type(col_type))
+    assert table1 == expected
 
 
-def test_add_column_invalid_duplicate_column_name_error() -> None:
+def test_should_raise_error_if_column_name_exists() -> None:
     table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
     with pytest.raises(DuplicateColumnNameError):
         table1 = table1.add_column(Column("col1", ["a", "b", "c"]))
 
 
-def test_add_column_invalid_column_size_error() -> None:
+def test_should_raise_error_if_column_size_invalid() -> None:
     table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
     with pytest.raises(ColumnSizeError):
         table1 = table1.add_column(Column("col3", ["a", "b", "c", "d"]))

tests/safeds/data/tabular/containers/_table/test_add_columns.py

@@ -1,31 +1,62 @@
+import pytest
 from safeds.data.tabular.containers import Column, Table
-from safeds.data.tabular.typing import Integer, String
-
-
-def test_add_columns_valid() -> None:
-    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
-    col3 = Column("col3", [0, -1, -2])
-    col4 = Column("col4", ["a", "b", "c"])
-    table1 = table1.add_columns([col3, col4])
-    assert table1.number_of_columns == 4
-    assert table1.get_column("col3") == col3
-    assert table1.get_column("col4") == col4
-    assert isinstance(table1.schema.get_column_type("col1"), Integer)
-    assert isinstance(table1.schema.get_column_type("col2"), Integer)
-    assert isinstance(table1.schema.get_column_type("col3"), Integer)
-    assert isinstance(table1.schema.get_column_type("col4"), String)
-
-
-def test_add_columns_table_valid() -> None:
-    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
-    col3 = Column("col3", [0, -1, -2])
-    col4 = Column("col4", ["a", "b", "c"])
-    table2 = Table.from_columns([col3, col4])
+from safeds.data.tabular.exceptions import ColumnSizeError, DuplicateColumnNameError
+
+
+@pytest.mark.parametrize(
+    ("table1", "column1", "column2", "expected"),
+    [
+        (
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+            Column("col3", [0, -1, -2]),
+            Column("col4", ["a", "b", "c"]),
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4], "col3": [0, -1, -2], "col4": ["a", "b", "c"]}),
+        ),
+    ],
+    ids=["add 2 columns"],
+)
+def test_should_add_columns(table1: Table, column1: Column, column2: Column, expected: Table) -> None:
+    table1 = table1.add_columns([column1, column2])
+    assert table1 == expected
+
+
+@pytest.mark.parametrize(
+    ("table1", "table2", "expected"),
+    [
+        (
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+            Table.from_dict({"col3": [0, -1, -2], "col4": ["a", "b", "c"]}),
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4], "col3": [0, -1, -2], "col4": ["a", "b", "c"]}),
+        ),
+    ],
+    ids=["add a table with 2 columns"],
+)
+def test_should_add_columns_from_table(table1: Table, table2: Table, expected: Table) -> None:
     table1 = table1.add_columns(table2)
-    assert table1.number_of_columns == 4
-    assert table1.get_column("col3") == col3
-    assert table1.get_column("col4") == col4
-    assert isinstance(table1.schema.get_column_type("col1"), Integer)
-    assert isinstance(table1.schema.get_column_type("col2"), Integer)
-    assert isinstance(table1.schema.get_column_type("col3"), Integer)
-    assert isinstance(table1.schema.get_column_type("col4"), String)
+    assert table1 == expected
+
+
+@pytest.mark.parametrize(
+    ("table", "columns"),
+    [
+        (Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+         [Column("col3", ["a", "b", "c", "d"]), Column("col4", ["e", "f", "g", "h"])]),
+    ],
+    ids=["Two Columns with too many values"]
+)
+def test_should_raise_error_if_column_size_invalid(table: Table, columns: list[Column] | Table) -> None:
+    with pytest.raises(ColumnSizeError):
+        table = table.add_columns(columns)
+
+
+@pytest.mark.parametrize(
+    ("table", "columns"),
+    [
+        (Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+         [Column("col2", ["a", "b", "c"]), Column("col3", [2, 3, 4])]),
+    ],
+    ids=["Column already exists"]
+)
+def test_should_raise_error_if_column_name_in_result_column(table: Table, columns: list[Column] | Table) -> None:
+    with pytest.raises(DuplicateColumnNameError):
+        table = table.add_columns(columns)

tests/safeds/data/tabular/containers/_table/test_add_row.py

@@ -1,18 +1,24 @@
+import pytest
 from _pytest.python_api import raises
 from safeds.data.tabular.containers import Row, Table
 from safeds.data.tabular.exceptions import SchemaMismatchError
 
 
-def test_add_row_valid() -> None:
-    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
-    row = Row({"col1": 5, "col2": 6})
-    table1 = table1.add_row(row)
-    assert table1.number_of_rows == 4
-    assert table1.get_row(3) == row
-    assert table1.schema == row._schema
+@pytest.mark.parametrize(
+    ("table", "row"),
+    [
+        (Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}), Row({"col1": 5, "col2": 6})),
+    ],
+    ids=["added row"],
+)
+def test_should_add_row(table: Table, row: Row) -> None:
+    table = table.add_row(row)
+    assert table.number_of_rows == 4
+    assert table.get_row(3) == row
+    assert table.schema == row._schema
 
 
-def test_add_row_invalid() -> None:
+def test_should_raise_error_if_row_schema_invalid() -> None:
     table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
     row = Row({"col1": 5, "col2": "Hallo"})
     with raises(SchemaMismatchError):

tests/safeds/data/tabular/containers/_table/test_add_rows.py

@@ -1,59 +1,47 @@
-import pandas as pd
+import pytest
 from safeds.data.tabular.containers import Row, Table
+from safeds.data.tabular.exceptions import SchemaMismatchError
 
 
-def test_add_rows_valid() -> None:
-    table1 = Table.from_dict({"col1": ["a", "b", "c"], "col2": [1, 2, 4]})
-    row1 = Row._from_pandas_dataframe(
-        pd.DataFrame(
-            {
-                "col1": ["d"],
-                "col2": [6],
-            },
-        ),
-        table1.schema,
-    )
-    row2 = Row._from_pandas_dataframe(
-        pd.DataFrame(
-            {
-                "col1": ["e"],
-                "col2": [8],
-            },
+
+@pytest.mark.parametrize(
+    ("table1", "row1", "row2", "table2"),
+    [
+        (
+            Table.from_dict({"col1": ["a", "b", "c"], "col2": [1, 2, 4]}),
+            Row({"col1": "d", "col2": 6}),
+            Row({"col1": "e", "col2": 8}),
+            Table.from_dict({"col1": ["a", "b", "c", "d", "e"], "col2": [1, 2, 4, 6, 8]}),
         ),
-        table1.schema,
-    )
+    ],
+    ids=["Rows with string and integer values"],
+)
+def test_should_add_rows(table1: Table, row1: Row, row2: Row, table2: Table) -> None:
     table1 = table1.add_rows([row1, row2])
-    assert table1.number_of_rows == 5
-    assert table1.get_row(3) == row1
-    assert table1.get_row(4) == row2
-    assert table1.schema == row1._schema
-    assert table1.schema == row2._schema
+    assert table1 == table2
 
 
-def test_add_rows_table_valid() -> None:
-    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
-    row1 = Row._from_pandas_dataframe(
-        pd.DataFrame(
-            {
-                "col1": [5],
-                "col2": [6],
-            },
-        ),
-        table1.schema,
-    )
-    row2 = Row._from_pandas_dataframe(
-        pd.DataFrame(
-            {
-                "col1": [7],
-                "col2": [8],
-            },
+@pytest.mark.parametrize(
+    ("table1", "table2", "expected"),
+    [
+        (
+            Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]}),
+            Table.from_dict({"col1": [5, 7], "col2": [6, 8]}),
+            Table.from_dict({"col1": [1, 2, 1, 5, 7], "col2": [1, 2, 4, 6, 8]}),
         ),
-        table1.schema,
-    )
-    table2 = Table.from_rows([row1, row2])
+    ],
+    ids=["Rows from table"],
+)
+def test_should_add_rows_from_table(table1: Table, table2: Table, expected: Table) -> None:
     table1 = table1.add_rows(table2)
-    assert table1.number_of_rows == 5
-    assert table1.get_row(3) == row1
-    assert table1.get_row(4) == row2
-    assert table1.schema == row1._schema
-    assert table1.schema == row2._schema
+    assert table1 == expected
+
+
+def test_should_raise_error_if_row_schema_invalid() -> None:
+    table1 = Table.from_dict({"col1": [1, 2, 1], "col2": [1, 2, 4]})
+    row = [
+        Row({"col1": 2, "col2": 4}),
+        Row({"col1": 5, "col2": "Hallo"})
+    ]
+    with pytest.raises(SchemaMismatchError):
+        table1 = table1.add_rows(row)

tests/safeds/data/tabular/containers/_table/test_column_names.py

@@ -1,11 +1,14 @@
+import pytest
 from safeds.data.tabular.containers import Table
 
 
-def test_column_names() -> None:
-    table = Table.from_dict({"col1": [1], "col2": [1]})
-    assert table.column_names == ["col1", "col2"]
-
-
-def test_get_column_names_empty() -> None:
-    table = Table([])
-    assert table.column_names == []
+@pytest.mark.parametrize(
+    ("table", "expected"),
+    [
+        ((Table.from_dict({"col1": [1], "col2": [1]}), ["col1", "col2"])),
+        (Table([]), []),
+    ],
+    ids=["Integer", "empty"],
+)
+def test_should_compare_column_names(table: Table, expected: list) -> None:
+    assert table.column_names == expected

tests/safeds/data/tabular/containers/_table/test_dataframe.py

@@ -14,14 +14,14 @@
         "non-empty",
     ],
 )
-def test_can_restore_table_from_exchange_object(table: Table) -> None:
+def test_should_restore_table_from_exchange_object(table: Table) -> None:
     exchange_object = table.__dataframe__()
     restored = Table(from_dataframe(exchange_object))
 
     assert restored == table
 
 
-def test_should_raise_if_allow_copy_is_false() -> None:
+def test_should_raise_error_if_allow_copy_is_false() -> None:
     table = Table.from_dict({})
     with pytest.raises(NotImplementedError, match="`allow_copy` must be True"):
         table.__dataframe__(allow_copy=False)

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

@@ -0,0 +1,55 @@
+from typing import Any
+
+import pytest
+from safeds.data.tabular.containers import Column, Row
+
+
+@pytest.mark.parametrize(
+    ("row1", "row2", "expected"),
+    [
+        (Row({}), Row({}), True),
+        (Row({"A": 1}), Row({"A": 1}), True),
+        (Row({"A": 1}), Row({"A": 2}), False),
+        (Row({"A": 1, "B": 2, "C": 3}), Row({"A": 2, "B": 4, "C": 3}), False),
+        (Row({"A": 1, "B": 2, "C": 3}), Row({"A": "1", "B": "2", "C": "3"}), False),
+    ],
+    ids=[
+        "empty Row",
+        "equal Row",
+        "different names",
+        "different values",
+        "different types",
+    ],
+)
+def test_should_return_whether_two_columns_are_equal(row1: Row, row2: Row, expected: bool) -> None:
+    assert (row1.__eq__(row2)) == expected
+
+
+@pytest.mark.parametrize(
+    "row",
+    [
+        Row({}),
+        Row({"A": 1, "B": 2, "C": 3}),
+    ],
+    ids=[
+        "empty",
+        "non-empty",
+    ],
+)
+def test_should_return_true_if_objects_are_identical(row: Row) -> None:
+    assert (row.__eq__(row)) is True
+
+
+@pytest.mark.parametrize(
+    ("row", "other"),
+    [
+        (Row({}), None),
+        (Row({"A": 1}), Column("col1")),
+    ],
+    ids=[
+        "Row vs. None",
+        "Row vs. Column",
+    ],
+)
+def test_should_return_not_implemented_if_other_is_not_column(row: Row, other: Any) -> None:
+    assert (row.__eq__(other)) is NotImplemented