ok

Author: joyguoguo

fuzz/collect_fuzz_python.py

@@ -212,9 +212,8 @@ def generate_test_template(target_name: str, repo_path: str):
 class Test{target_name.capitalize()}(unittest.TestCase):
     def test_generated(self):
         \"\"\"Test generated from fuzzing input\"\"\"
-        input_data = b""  # FUZZ_PLACEHOLDER
+        input_data = b""  
         result = TestClass(input_data)
-        self.assertIsNotNone(result)
 
 if __name__ == '__main__':
     unittest.main()
@@ -313,6 +312,7 @@ def substitute_one_repo(
 ):
     """
     Process a single repository, replace fuzzing inputs into test templates
+    and generate {target_name}.inputs.py files.
     """
     template_dir = pjoin(repo, "tests-gen")
     input_dir = pjoin(repo, "fuzz_inputs")
@@ -324,21 +324,13 @@ def substitute_one_repo(
             f.write("")
 
     for target_name in targets:
-        template_path = pjoin(template_dir, f"{target_name}.py")
         input_path = pjoin(input_dir, target_name)
 
         try:
-            if not os.path.exists(template_path):
-                logging.warning(f"Template file not found: {template_path}")
-                continue
-
             if not os.path.exists(input_path):
                 logging.warning(f"Input file not found: {input_path}")
                 continue
 
-            with open(template_path) as f_template:
-                template = f_template.read()
-
             with open(input_path, "r") as f_input:
                 all_inputs = [line.strip() for line in f_input if line.strip()]
 
@@ -363,62 +355,47 @@ def substitute_one_repo(
             else:
                 inputs = all_inputs[:n_fuzz]
 
-            # Extract structure from template
-            match = re.search(r"(class\s+Test\w+\(unittest\.TestCase\):)", template)
-            if not match:
-                logging.error(f"Class definition not found in template: {template_path}")
-                continue
+            # Header
+            file_header = f"""import sys
+import os
+import unittest
 
-            class_def_index = match.start()
-            before_class = template[:class_def_index]
-            class_and_after = template[class_def_index:]
+# 将项目目录加入 Python 路径，确保能导入上层模块
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
-            method_match = re.search(r"def\s+test_generated\(self\):", class_and_after)
-            if not method_match:
-                logging.error(f"test_generated method not found in template: {template_path}")
-                continue
+try:
+    from {target_name} import TestOneInput as TestClass
+except ImportError:
+    from {target_name} import TestInput as TestClass
+
+
+class Test{target_name.capitalize()}(unittest.TestCase):"""
 
-            method_start = method_match.end()
-            class_header = class_and_after[:method_start]
-            method_indent_block = class_and_after[method_start:]
-
-            method_lines = method_indent_block.splitlines()
-            method_body = []
-            footer_lines = []
-            for line in method_lines:
-                if line.strip() == "":
-                    continue
-                if not line.startswith("        "):  # outside method block
-                    footer_lines.append(line)
-                elif not footer_lines:  # still inside method
-                    method_body.append(line)
-
-            method_body_str = "\n".join(method_body)
-            footer_str = "\n".join(footer_lines)
-
-            # Build all test methods
+            # Method body template
+            method_body_template = [
+                '"""Test generated from fuzzing input"""',
+                'input_data = b""',
+                'result = TestClass(input_data)',
+            ]
+
+            # Generate test methods
             test_methods = []
             for i, input_data in enumerate(inputs):
                 escaped_input = escape_special_chars(input_data)
                 test_func = f"    def test_{i}(self):\n"
-                test_func += "\n".join(
-                    "        " + line.lstrip().replace('input_data = b""', f"input_data = {escaped_input}")
-                    for line in method_body if line.strip()
-                )
+                for line in method_body_template:
+                    replaced_line = line.replace('input_data = b""', f"input_data = {escaped_input}")
+                    test_func += f"        {replaced_line}\n"
                 test_methods.append(test_func)
 
             if not test_methods:
-                # Fallback: generate dummy method to avoid syntax error
                 test_methods = ["    def test_placeholder(self):\n        self.assertTrue(True)"]
 
-            final_code = before_class.rstrip() + "\n" + class_header.rstrip() + "\n\n"
-            final_code += "\n\n".join(test_methods).rstrip() + "\n"
-
-            if footer_str.strip():
-                final_code += "\n\n" + footer_str.strip() + "\n"
+            # Combine full file
+            final_code = file_header + "\n\n" + "\n\n".join(test_methods)
+            final_code += "\n\nif __name__ == '__main__':\n    unittest.main()\n"
 
-
-            # Write to output
+            # Write output file
             generated_path = pjoin(template_dir, f"{target_name}.inputs.py")
             with open(generated_path, "w") as f:
                 f.write(final_code)
@@ -432,6 +409,7 @@ def substitute_one_repo(
         except Exception as e:
             logging.error(f"Error processing {target_name}: {e}")
 
+
 def testgen_repos(
     repos: list[str],
     jobs: int,
@@ -471,10 +449,10 @@ def testgen_repos(
         ))
 
 def main(
-    repo_id: str = "data/valid_projects3.txt",
+    repo_id: str = "data/valid_projects.txt",
     repo_root: str = "fuzz/oss-fuzz/projects/",
     timeout: int = 60,
-    jobs: int = 8,
+    jobs: int = 4,
     pipeline: str = "all",
     n_fuzz: int = 100,
     strategy: str = "shuffle",