Fix linting

jorg-vr · jorg-vr · commit 03b7e3c109a6 · 2025-03-10T13:40:47.000+01:00
diff --git a/tested/languages/cpp/generators.py b/tested/languages/cpp/generators.py
@@ -62,21 +62,21 @@ def convert_type(self, value: Expression) -> str:
             return self.convert_declaration(value.type, value)
 
     def combine_types(self, expressions: list[Expression]) -> str:
-            content_types = set(self.convert_type(content) for content in expressions)
-            if len(content_types) == 1:
-                return content_types.pop()
-            elif len(content_types) > 1:
-                return f"std::variant<{', '.join(content_types)}>"
-            else:
-                return "std::any"
+        content_types = set(self.convert_type(content) for content in expressions)
+        if len(content_types) == 1:
+            return content_types.pop()
+        elif len(content_types) > 1:
+            return f"std::variant<{', '.join(content_types)}>"
+        else:
+            return "std::any"
 
     def sequence_subtype(self, value: Statement) -> str:
         if isinstance(value, SequenceType):
             return self.combine_types(value.data)
         else:
             return "std::any"
 
-    def convert_value(self, value: Value, add_type = False) -> str:
+    def convert_value(self, value: Value, add_type=False) -> str:
         basic = as_basic_type(value)
         if add_type:
             tp = value.type
@@ -87,12 +87,14 @@ def convert_value(self, value: Value, add_type = False) -> str:
             if bt == BasicNothingTypes.NOTHING:
                 return value_string
 
-            if (tp == AdvancedNumericTypes.DOUBLE_EXTENDED
+            if (
+                tp == AdvancedNumericTypes.DOUBLE_EXTENDED
                 or tp == AdvancedNumericTypes.DOUBLE_PRECISION
                 or tp == AdvancedNumericTypes.SINGLE_PRECISION
                 or tp == AdvancedStringTypes.CHAR
                 or bt == BasicBooleanTypes.BOOLEAN
-                or bt == BasicNumericTypes.REAL):
+                or bt == BasicNumericTypes.REAL
+            ):
                 return f"(({type_string}) {value_string})"
 
             return f"{type_string}({value_string})"
@@ -116,7 +118,8 @@ def convert_value(self, value: Value, add_type = False) -> str:
                 + "}"
             )
         elif (
-            basic.type == BasicSequenceTypes.SEQUENCE or basic.type == BasicSequenceTypes.SET
+            basic.type == BasicSequenceTypes.SEQUENCE
+            or basic.type == BasicSequenceTypes.SET
         ):
             return (
                 "{"
@@ -195,7 +198,9 @@ def convert_declaration(
             return f"std::vector<{self.sequence_subtype(value)}>"
         elif tp == AdvancedSequenceTypes.TUPLE:
             if isinstance(value, SequenceType):
-                subtype_string = ", ".join(self.convert_type(content) for content in value.data)
+                subtype_string = ", ".join(
+                    self.convert_type(content) for content in value.data
+                )
                 return f"std::tuple<{subtype_string}>"
             else:
                 return "std::tuple<std::any>"
@@ -226,7 +231,7 @@ def convert_declaration(
             return "void"
         raise AssertionError(f"Unknown type: {tp!r}")
 
-    def convert_statement(self, statement: Statement, add_value_type = False) -> str:
+    def convert_statement(self, statement: Statement, add_value_type=False) -> str:
         if isinstance(statement, PropertyAssignment):
             return (
                 f"{self.convert_statement(statement.property)} = "
@@ -248,7 +253,11 @@ def convert_statement(self, statement: Statement, add_value_type = False) -> str
         raise AssertionError(f"Unknown statement: {statement!r}")
 
     def is_pascal_case(self, identifier: Identifier) -> bool:
-        return len(identifier) > 0 and identifier[0].isupper() and not identifier[1:].isupper()
+        return (
+            len(identifier) > 0
+            and identifier[0].isupper()
+            and not identifier[1:].isupper()
+        )
 
     def convert_function_call(self, function: FunctionCall) -> str:
         result = function.name
@@ -273,13 +282,17 @@ def convert_function_call(self, function: FunctionCall) -> str:
                 else:
                     result = f"{function.namespace}.{result}"
             else:
-                result = "(" + self.convert_statement(function.namespace) + ")." + result
+                result = (
+                    "(" + self.convert_statement(function.namespace) + ")." + result
+                )
         return result
 
     def spacing(self, depth):
         return " " * depth * 4
 
-    def convert_testcase(self, tc: PreparedTestcase, pu: PreparedExecutionUnit, depth = 1) -> str:
+    def convert_testcase(
+        self, tc: PreparedTestcase, pu: PreparedExecutionUnit, depth=1
+    ) -> str:
         indent = self.spacing(depth)
         result = ""
         if tc.testcase.is_main_testcase():
@@ -320,17 +333,23 @@ def generate_internal_context(
         # Generate code for each testcase
         tc: PreparedTestcase
         for i, tc in enumerate(ctx.testcases):
-            result += self.spacing(i+1) + "try {" + "\n"
-            result += self.spacing(i+2) + f"{pu.unit.name}_write_separator();\n"
-            result += self.convert_testcase(tc, pu, i+2)
-
-        for i in range(len(ctx.testcases), 0, -1):
-            result += self.spacing(i) + "} catch (...) {\n"
-            result += self.spacing(i+1) + "const std::exception_ptr &e = std::current_exception();\n"
-            result += self.spacing(i+1) + self.convert_statement(
-                tc.exception_statement("e")) + ";\n"
-            result += self.spacing(i+1)+ "exit_code = 1;\n"
-            result += self.spacing(i) + "}\n"
+            result += self.spacing(i + 1) + "try {" + "\n"
+            result += self.spacing(i + 2) + f"{pu.unit.name}_write_separator();\n"
+            result += self.convert_testcase(tc, pu, i + 2)
+
+        for i in range(len(ctx.testcases) - 1, -1, -1):
+            result += self.spacing(i + 1) + "} catch (...) {\n"
+            result += (
+                self.spacing(i + 2)
+                + "const std::exception_ptr &e = std::current_exception();\n"
+            )
+            result += (
+                self.spacing(i + 2)
+                + self.convert_statement(ctx.testcases[i].exception_statement("e"))
+                + ";\n"
+            )
+            result += self.spacing(i + 2) + "exit_code = 1;\n"
+            result += self.spacing(i + 1) + "}\n"
 
         result += self.spacing(1) + ctx.after + "\n"
         result += self.spacing(1) + "return exit_code;\n"
@@ -460,7 +479,10 @@ def convert_encoder(self, values: list[Value]) -> str:
 int main() {
 """
         for value in values:
-            result += self.spacing(1) + f"write_value(std::cout, {self.convert_value(value, True)});\n"
+            result += (
+                self.spacing(1)
+                + f"write_value(std::cout, {self.convert_value(value, True)});\n"
+            )
             result += self.spacing(1) + 'std::cout << "␞";\n'
         result += "}\n"
         return result
diff --git a/tests/test_language_quircks.py b/tests/test_language_quircks.py
@@ -25,45 +25,61 @@
 from tested.testsuite import Suite
 from tests.manual_utils import assert_valid_output, configuration, execute_config
 
+
 def test_cpp_function_assignment(tmp_path: Path, pytestconfig: pytest.Config):
     statement_string = "test: string = foo()"
     cpp = LANGUAGES["cpp"](pytestconfig)
     result = cpp.generate_statement(parse_string(statement_string))
 
     assert result == "std::string test = foo()"
 
+
 def test_cpp_complex_function_assignment(tmp_path: Path, pytestconfig: pytest.Config):
-    statement_string = "test = { \"a\": foo() }"
+    statement_string = 'test = { "a": foo() }'
     cpp = LANGUAGES["cpp"](pytestconfig)
     result = cpp.generate_statement(parse_string(statement_string))
 
-    assert result == "std::map<std::string, std::any> test = {{\"a\", foo()}}"
+    assert result == 'std::map<std::string, std::any> test = {{"a", foo()}}'
 
-def test_cpp_types_get_cast_within_functions(tmp_path: Path, pytestconfig: pytest.Config):
-    statement_string = "test: string = foo(1, \"2\", [3, 4], (5, 6), {7: 8})"
+
+def test_cpp_types_get_cast_within_functions(
+    tmp_path: Path, pytestconfig: pytest.Config
+):
+    statement_string = 'test: string = foo(1, "2", [3, 4], (5, 6), {7: 8})'
     cpp = LANGUAGES["cpp"](pytestconfig)
     result = cpp.generate_statement(parse_string(statement_string))
 
     int_p = "std::intmax_t(1)"
-    str_p = "std::string(\"2\")"
+    str_p = 'std::string("2")'
     vec_p = "std::vector<std::intmax_t>({3, 4})"
     tuple_p = "std::tuple<std::intmax_t, std::intmax_t>({5, 6})"
     map_p = "std::map<std::intmax_t, std::intmax_t>({{7, 8}})"
-    assert result == f"std::string test = foo({int_p}, {str_p}, {vec_p}, {tuple_p}, {map_p})"
+    assert (
+        result
+        == f"std::string test = foo({int_p}, {str_p}, {vec_p}, {tuple_p}, {map_p})"
+    )
+
 
 def test_cpp_complex_type_assignment(tmp_path: Path, pytestconfig: pytest.Config):
     statement_string = "test = {'1': [2 , (3, {4, 5})]}"
     cpp = LANGUAGES["cpp"](pytestconfig)
     result = cpp.generate_statement(parse_string(statement_string))
 
-    variant_types = ["std::intmax_t", "std::tuple<std::intmax_t, std::set<std::intmax_t>>"]
+    variant_types = [
+        "std::intmax_t",
+        "std::tuple<std::intmax_t, std::set<std::intmax_t>>",
+    ]
     permutations = list(itertools.permutations(variant_types))
-    valid_types = [f"std::map<std::string, std::vector<std::variant<{", ".join(perm)}>>>" for perm in permutations]
-    valid_value = "{{\"1\", {2, {3, {4, 5}}}}}"
+    valid_types = [
+        f"std::map<std::string, std::vector<std::variant<{", ".join(perm)}>>>"
+        for perm in permutations
+    ]
+    valid_value = '{{"1", {2, {3, {4, 5}}}}}'
     valid_results = [f"{tp1} test = {valid_value}" for tp1 in valid_types]
 
     assert result in valid_results
 
+
 def test_cpp_static_functions(tmp_path: Path, pytestconfig: pytest.Config):
     cpp = LANGUAGES["cpp"](pytestconfig)
     object_function = "foo.bar()"
@@ -81,6 +97,7 @@ def test_cpp_static_functions(tmp_path: Path, pytestconfig: pytest.Config):
 
     assert result == "(foo()).bar()"
 
+
 def test_cpp_unknown_return_type_without_streamable_is_null(
     tmp_path: Path, pytestconfig: pytest.Config
 ):
@@ -96,7 +113,7 @@ def test_cpp_unknown_return_type_without_streamable_is_null(
     updates = assert_valid_output(result, pytestconfig)
     assert updates.find_status_enum() == ["wrong"]
     received_data = updates.find_next("close-test")["generated"]
-    assert received_data == 'None'
+    assert received_data == "None"
 
 
 def test_typescript_array_typing(tmp_path: Path, pytestconfig: pytest.Config):
diff --git a/tests/test_parallel_execution.py b/tests/test_parallel_execution.py
@@ -24,14 +24,7 @@ def test_parallel_isbn(lang: str, tmp_path: Path, pytestconfig: pytest.Config):
 
 @pytest.mark.parametrize(
     "lang",
-    [
-        "java",
-        "python",
-        "kotlin",
-        "haskell",
-        "runhaskell",
-        "cpp"
-    ],
+    ["java", "python", "kotlin", "haskell", "runhaskell", "cpp"],
 )
 def test_parallel_isbn_list(lang: str, tmp_path: Path, pytestconfig: pytest.Config):
     config_ = {"options": {"parallel": True}}
