test case fix

Author: Lavisha Gupta

compiler/fory_compiler/generators/go.py

@@ -199,6 +199,45 @@ def message_has_unions(self, message: Message) -> bool:
         PrimitiveKind.ANY: "any",
     }
 
+    def wrap_line(
+        self,
+        line: str,
+        max_width: int = 80,
+        indent: str = "",
+        continuation_indent: str = None,
+    ) -> List[str]:
+        """Override base wrap_line to handle Go-specific syntax.
+        
+        Go has specific constructs that should not be wrapped:
+        1. Function signatures - must not split between params and return type
+        2. Struct field tags - backtick strings must not be split
+        3. Single-line function bodies - must not split "{ return ... }"
+        """
+        if continuation_indent is None:
+            continuation_indent = indent + "    "
+        
+        # If line is already short enough, return as is
+        if len(line) <= max_width:
+            return [line]
+        
+        stripped = line.lstrip()
+        
+        # Don't wrap comments
+        if stripped.startswith("//") or stripped.startswith("/*") or stripped.startswith("*"):
+            return [line]
+        
+        # Don't wrap lines with backticks (struct tags)
+        if "`" in line:
+            return [line]
+        
+        # Don't wrap function definitions (including one-liners like "func Foo() Type { return ... }")
+        # Detect by checking if line starts with "func " and contains "{"
+        if stripped.startswith("func ") and "{" in line:
+            return [line]
+        
+        # For all other cases, use base class wrapping
+        return super().wrap_line(line, max_width, indent, continuation_indent)
+
     def generate(self) -> List[GeneratedFile]:
         """Generate Go files for the schema."""
         files = []
@@ -586,15 +625,13 @@ def generate_union(
             lines.append(f"\tcase {case_type}{case_name}:")
             lines.append(f"\t\tv, ok := u.value.({case_type_name})")
             lines.append("\t\tif !ok {")
-            lines.append(
-                f'\t\t\treturn fmt.Errorf("corrupted {type_name}: case={case_name} but invalid value")'
-            )
+            lines.append(f'\t\t\treturn fmt.Errorf("corrupted {type_name}: " +')
+            lines.append(f'\t\t\t\t"case={case_name} but invalid value")')
             lines.append("\t\t}")
             if case_type_name.startswith("*"):
                 lines.append("\t\tif v == nil {")
-                lines.append(
-                    f'\t\t\treturn fmt.Errorf("corrupted {type_name}: case={case_name} but nil value")'
-                )
+                lines.append(f'\t\t\treturn fmt.Errorf("corrupted {type_name}: " +')
+                lines.append(f'\t\t\t\t"case={case_name} but nil value")')
                 lines.append("\t\t}")
             lines.append(f"\t\tif visitor.{case_name} != nil {{")
             lines.append(f"\t\t\treturn visitor.{case_name}(v)")
@@ -864,7 +901,8 @@ def generate_field(
 
         if tags:
             tag_str = ",".join(tags)
-            lines.append(f'{field_name} {go_type} `fory:"{tag_str}"`')
+            # Concatenate parts to ensure single line in output
+            lines.append(f"{field_name} {go_type} `fory:\"{tag_str}\"`")
         else:
             lines.append(f"{field_name} {go_type}")
 

compiler/fory_compiler/generators/java.py

@@ -658,7 +658,8 @@ def generate_union_class(
             lines.append(f"{ind}                return {type_id_expr};")
         lines.append(f"{ind}            default:")
         lines.append(
-            f'{ind}                throw new IllegalStateException("Unknown {union.name} case id: " + caseId);'
+            f'{ind}                throw new IllegalStateException("Unknown " + '
+            f'"{union.name} case id: " + caseId);'
         )
         lines.append(f"{ind}        }}")
         lines.append(f"{ind}    }}")
@@ -694,7 +695,8 @@ def generate_union_class(
             lines.append(f"{ind}                return {case_enum}.{case_enum_name};")
         lines.append(f"{ind}            default:")
         lines.append(
-            f'{ind}                throw new IllegalStateException("Unknown {union.name} case id: " + index);'
+            f'{ind}                throw new IllegalStateException("Unknown " + '
+            f'"{union.name} case id: " + index);'
         )
         lines.append(f"{ind}        }}")
         lines.append(f"{ind}    }}")

compiler/fory_compiler/generators/python.py

@@ -141,6 +141,57 @@ class PythonGenerator(BaseGenerator):
         PrimitiveKind.ANY: "None",
     }
 
+    def wrap_line(
+        self,
+        line: str,
+        max_width: int = 80,
+        indent: str = "",
+        continuation_indent: str = None,
+    ) -> List[str]:
+        """Override base wrap_line to handle Python-specific syntax.
+        
+        Python has specific constructs that should not be wrapped:
+        1. Assignment statements - must not split between variable and value
+        2. Conditional statements with logical operators (and, or, not)
+        3. Raise statements with string literals
+        """
+        if continuation_indent is None:
+            continuation_indent = indent + "    "
+        
+        # If line is already short enough, return as is
+        if len(line) <= max_width:
+            return [line]
+        
+        stripped = line.lstrip()
+        
+        # Don't wrap comments
+        if stripped.startswith("#"):
+            return [line]
+        
+        # Don't wrap raise statements (they often have long string literals)
+        if stripped.startswith("raise "):
+            return [line]
+        
+        # Don't wrap assignment statements (lines containing " = " at the statement level)
+        # This prevents splitting like: _threadsafe_fory = pyfory.ThreadSafeFory(...)
+        # Only check for simple assignments (not comparisons or keyword args)
+        if " = " in line and not line.strip().startswith("if ") and not line.strip().startswith("elif ") and not line.strip().startswith("while "):
+            # Check if this looks like a simple assignment (has = but not == or <= or >=)
+            # and the = comes before any opening parentheses
+            eq_pos = line.find(" = ")
+            paren_pos = line.find("(")
+            if eq_pos > 0 and (paren_pos < 0 or eq_pos < paren_pos):
+                # This is likely an assignment statement, don't wrap it
+                return [line]
+        
+        # Don't wrap conditional statements (if/elif/while) with logical operators
+        # This prevents splitting like: if condition and not\n    isinstance(...)
+        if stripped.startswith(("if ", "elif ", "while ")) and (" and " in line or " or " in line):
+            return [line]
+        
+        # For all other cases, use base class wrapping
+        return super().wrap_line(line, max_width, indent, continuation_indent)
+
     def safe_name(self, name: str) -> str:
         """Return a Python-safe identifier."""
         if keyword.iskeyword(name):