testgenie-py 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

testgen/util/utils.py

@@ -1,5 +1,6 @@
 
 import ast
+import os
 import string
 import sys
 import random
@@ -7,12 +8,11 @@ from typing import List
 
 from atheris import FuzzedDataProvider
 
+import testgen.util.file_utils
+from testgen.models.function import Function
+from testgen.models.test_case import TestCase
 from testgen.util.file_utils import load_and_parse_file_for_tree
 
-
-def get_func(module, func_name:str):
-    return getattr(module, func_name)
-
 def extract_parameter_types(func_node):
     """Extract parameter types from a function node."""
     param_types = {}
@@ -51,39 +51,6 @@ def generate_random_inputs(param_types):
             inputs[param] = None
     return inputs
 
-def generate_extreme_inputs(param_types):
-    inputs = {}
-    for param, param_type in param_types.items():
-        if param_type == "int":
-            # int is unbounded in Python, but sys.maxsize is the max value representable by a signed word
-            inputs[param] = sys.maxsize
-        if param_type == "bool":
-            random_choice = random.choice([1, 0])
-            inputs[param] = random_choice
-        if param_type == "float":
-            random_choice = random.choice([sys.float_info.min, sys.float_info.max])
-            inputs[param] = random_choice
-        if param_type == "str":
-            inputs[param] = ''.join(random.choice([string.ascii_letters, string.digits, string.punctuation, string.whitespace]) for _ in range(100))
-
-def generate_inputs_from_fuzz_data(fdp: FuzzedDataProvider, param_types):
-    """Generate fuzzed inputs based on parameter types."""
-    inputs = []
-    for param_type in param_types.values():
-        if param_type == "int":
-            inputs.append(fdp.ConsumeInt(4))
-        elif param_type == "bool":
-            inputs.append(fdp.ConsumeBool())
-        elif param_type == "float":
-            inputs.append(fdp.ConsumeFloat())
-        elif param_type == "str":
-            inputs.append(fdp.ConsumeString(10))
-        elif param_type == "bytes":
-            inputs.append(fdp.ConsumeBytes(10))
-        else:
-            inputs.append(None)
-    return tuple(inputs)
-
 def get_functions(tree) -> List[ast.FunctionDef]:
     functions = []
     for node in tree.body:
@@ -95,6 +62,41 @@ def get_functions(tree) -> List[ast.FunctionDef]:
                     functions.append(class_node)
     return functions
 
+def get_list_of_functions(filepath: str) -> List[Function]:
+    tree = load_and_parse_file_for_tree(filepath)
+    functions = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef):
+            params = extract_parameter_types(node)
+            start_line = node.lineno
+            end_line = max(
+                [line.lineno for line in ast.walk(node) if hasattr(line, 'lineno') and line.lineno],
+                default=start_line
+            )
+            num_lines = end_line - start_line + 1
+            name = node.name
+            source_file_id = -1  # Placeholder
+            functions.append(Function(name, str(params), start_line, end_line, num_lines, source_file_id))
+        if isinstance(node, ast.ClassDef):
+            for method in node.body:
+                if isinstance(method, ast.FunctionDef):
+                    params = extract_parameter_types(method)
+                    start_line = method.lineno
+                    end_line = max(
+                        [line.lineno for line in ast.walk(method) if hasattr(line, 'lineno') and line.lineno],
+                        default=start_line
+                    )
+                    num_lines = end_line - start_line + 1
+
+                    # Method name (prefixed with class name for clarity)
+                    name = f"{node.name}.{method.name}"
+
+                    # Source file ID will be set when adding to database
+                    source_file_id = -1  # Placeholder
+
+                    functions.append(Function(name, str(params), start_line, end_line, num_lines, source_file_id))
+    return functions
+
 def get_function_boundaries(file_name: str, func_name: str) -> tuple:
     tree = load_and_parse_file_for_tree(file_name)
     for i, node in enumerate(tree.body):
@@ -139,5 +141,162 @@ def get_function_boundaries(file_name: str, func_name: str) -> tuple:
     
     raise ValueError(f"Function {func_name} not found in {file_name}")
 
-    
+def parse_test_case_from_result_name(name: str, format: int) -> TestCase:
+    test_case = TestCase(None, (), None)
+    if format == 3:
+        test_case = parse_test_case_from_result_name_doctest(name)
+    elif format == 2:
+        test_case = parse_test_case_from_result_name_pytest(name, format)
+    elif format == 1:
+        test_case = parse_test_case_from_result_name_unittest(name, format)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+    return test_case
+
+def parse_test_case_from_result_name_pytest(name: str, format: int) -> TestCase:
+    parts_name = name.split("::")
+    test_filepath = parts_name[0]
+    print(f"Parse test case from result name pytest: {test_filepath}")
+    test_filepath = os.path.abspath(os.path.join(os.getcwd(), test_filepath))
+    test_function_name = parts_name[1]
+
+    if test_function_name.startswith("test_"):
+        function_name_with_int = test_function_name[5:]
+    else:
+        function_name_with_int = test_function_name
+
+    parts = function_name_with_int.rsplit('_', 1)
+    if len(parts) > 1 and parts[1].isdigit():
+        function_name = parts[0]
+    else:
+        function_name = function_name_with_int
+
+    args, expected = extract_test_case_data(test_filepath, test_function_name, format)
+
+    return TestCase(function_name, args, expected)
+
+def parse_test_case_from_result_name_unittest(name: str, format: int) -> TestCase:
+    parts_name = name.split("::")
+    test_filepath = parts_name[0]
+    test_function_name_with_mod = parts_name[1]
+    test_function_name = test_function_name_with_mod.split('.')[1]
+
+    args, expected = extract_test_case_data(test_filepath, test_function_name, format)
+
+    parts = test_function_name.rsplit('_', 1)
+    if len(parts) > 1 and parts[1].isdigit():
+        function_name = parts[0]
+    else:
+        function_name = test_function_name
+
+    return TestCase(function_name, args, expected)
+
+# TODO: Find a way to associate doctest results to the actual test case
+def parse_test_case_from_result_name_doctest(name: str) -> TestCase:
+    function_name = name.split("::")[1]
+    return TestCase(function_name, (), None)
+
+def extract_test_case_data(test_file_path: str, function_name: str, test_format: int):
+    if not os.path.exists(test_file_path):
+        print(f"Error: Test file not found: {test_file_path}")
+        return {}, None
+
+    try:
+        with open(test_file_path, 'r') as f:
+            file_content = f.read()
+
+        # For doctests, just return empty data since we can't easily extract it
+        if test_format == 3:  # Doctest format
+            return {}, None
+
+        # Parse the file using ast
+        tree = ast.parse(file_content)
+
+        # Look for test function definition based on format
+        if test_format == 1:  # Unittest
+            return _extract_unittest_data(tree, function_name)
+        elif test_format == 2:  # Pytest
+            return _extract_pytest_data(tree, function_name)
+        else:
+            return None
+
+    except Exception as e:
+        print(f"Error extracting test case data: {e}")
+        return None
+
+def _extract_unittest_data(tree: ast.AST, function_name: str):
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            # Look for test method within the class
+            for class_node in node.body:
+                if isinstance(class_node, ast.FunctionDef) and class_node.name == f"test_{function_name}":
+                    # Find 'args =' and 'expected =' assignments in the function body
+                    args_value = None
+                    expected_value = None
+
+                    for stmt in class_node.body:
+                        if isinstance(stmt, ast.Assign):
+                            if isinstance(stmt.targets[0], ast.Name):
+                                if stmt.targets[0].id == "args":
+                                    args_value = _extract_value(stmt.value)
+                                elif stmt.targets[0].id == "expected":
+                                    expected_value = _extract_value(stmt.value)
+
+                    if args_value is not None:
+                        # Convert args to dict for consistency
+                        if isinstance(args_value, tuple):
+                            return args_value, expected_value
+                        else:
+                            return (args_value,), expected_value
+
+    return None
+
+def _extract_pytest_data(tree: ast.AST, function_name: str):
+    """Extract args and expected output from pytest-style test file"""
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name == f"test_{function_name}":
+            # Find 'args =' and 'expected =' assignments in the function body
+            args_value = None
+            expected_value = None
+
+            for stmt in node.body:
+                if isinstance(stmt, ast.Assign):
+                    if isinstance(stmt.targets[0], ast.Name):
+                        if stmt.targets[0].id == "args":
+                            args_value = _extract_value(stmt.value)
+                        elif stmt.targets[0].id == "expected":
+                            expected_value = _extract_value(stmt.value)
+
+            if args_value is not None:
+                # Convert args to dict for consistency
+                if isinstance(args_value, tuple):
+                    return args_value, expected_value
+                else:
+                    return (args_value,), expected_value
+
+    return None
+
+def _extract_value(node: ast.AST):
+    """Convert an AST node to its Python value"""
+    if isinstance(node, ast.Tuple):
+        return tuple(_extract_value(elt) for elt in node.elts)
+    elif isinstance(node, ast.List):
+        return [_extract_value(elt) for elt in node.elts]
+    elif isinstance(node, ast.Dict):
+        return {_extract_value(key): _extract_value(value) for key, value in zip(node.keys, node.values)}
+    elif isinstance(node, ast.Constant):
+        return node.value
+
+
+    # If we can't determine the value, try using ast.unparse (Python 3.9+)
+    try:
+        return eval(ast.unparse(node))
+    except:
+        try:
+            # Fallback for older Python versions
+            code = compile(ast.Expression(node), '<string>', 'eval')
+            return eval(code)
+        except:
+            return None
+
 

{testgenie_py-0.3.7.dist-info → testgenie_py-0.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: testgenie-py
-Version: 0.3.7
+Version: 0.3.9
 Summary: Automated unit test generation tool for Python.
 Author: cjseitz
 Author-email: charlesjseitz@gmail.com

testgenie_py-0.3.9.dist-info/RECORD

@@ -0,0 +1,72 @@
+testgen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/analyzer/ast_analyzer.py,sha256=yHpGJLVlyTngcBED50I6j_sRBCIdoT9l7eWIFCsfbwQ,6307
+testgen/analyzer/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/analyzer/contracts/contract.py,sha256=6rNYJOy_2GrOhGtaXTDIOX6pTEOqo856FxG0yTc8amI,369
+testgen/analyzer/contracts/no_exception_contract.py,sha256=rTWTuu5XKmvzBPD6yNAqiNehk9lbWn_Z8zFj-_djZ_w,512
+testgen/analyzer/contracts/nonnull_contract.py,sha256=uurnrVptImYTVpSnu8ckdlU6c94AbiOWFoH1YnAQU0w,508
+testgen/analyzer/fuzz_analyzer.py,sha256=dzdMoJmosSgOfXCY-EhSLIM6vsdGeKiDqXj0iLS9qqk,3988
+testgen/analyzer/random_feedback_analyzer.py,sha256=1Hj2Zxhr98L35estFGFj8KHTEeo1dbccYiX_Tvz1nmw,11755
+testgen/analyzer/reinforcement_analyzer.py,sha256=rz47udd9DplWmnDeYtwf8_udcXqyLIBMwiz51KdMtQ4,2900
+testgen/analyzer/test_case_analyzer.py,sha256=0qLcRKOrQ4Uyh1ZMecVTkY9bWjNnx7OridigNyjfUk4,1620
+testgen/analyzer/test_case_analyzer_context.py,sha256=akOsq3xnG6himbwb4vpxcYthySj9rhRwXjoKBdFuW5c,1911
+testgen/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/controller/cli_controller.py,sha256=HXB8KvOkt8tWDFxP3NP5oVRlhRCCK6BpAn4BXyuZF8Q,8835
+testgen/controller/docker_controller.py,sha256=1GqRstLLl93JRDfn0mTmWABYl2fYVxA6QN_1aqhe0w4,9236
+testgen/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/db/dao.py,sha256=WXCXMrxHyqkB7oURPr0k_C5yDj8ifStZcn8nvpO5M5s,1957
+testgen/db/dao_impl.py,sha256=nE3JmhL_stOQ0XiIjK0_E31z1bHpwmNBTOW4HQvQIUg,8678
+testgen/db/db.py,sha256=ssQWNihmsyWMsmDWHNvWuYR63mtmUSxljMRJ3PwkUQU,2887
+testgen/docker/Dockerfile,sha256=6mutzP0ZkVueuvMLCOy2bsyGxWjLHU-cq7RFkuC8r5Y,781
+testgen/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/generator/code_generator.py,sha256=-Nh5Jt4my29YWA_LKWn98I4jvDA-fNi6AGuw-vJhRV0,3171
+testgen/generator/doctest_generator.py,sha256=B9I-nw7G7ubcx51XLOl1kiOEL0YW0aDuCAKebqfkRRI,8751
+testgen/generator/generator.py,sha256=9M9zg8DO0uU5W5s9hsz2oPCL7bz7sAD087M5TYottSs,2007
+testgen/generator/pytest_generator.py,sha256=UH1olGSePOtJ9zO1r8FsSV24tfO5c1cFoD5m7v5yTI0,2888
+testgen/generator/test_generator.py,sha256=D2Y3DaWH4fdIc5_9Xrznrkm0urFfhpYxuhL81M7RRaw,710
+testgen/generator/unit_test_generator.py,sha256=RwWJ2Pg5ITQx9ZInOtLbwGbjeXXDA1cjLsa9EG__RUk,3114
+testgen/main.py,sha256=sDaLZOKpw2PuExHYr10VDTrglbbWvBfKS6QCqUrHyrE,308
+testgen/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/models/analysis_context.py,sha256=-mhw_hn26MgF6aJnmj6Hub5jfCi8gmvcf4QNM4l7G2s,1442
+testgen/models/coverage_data.py,sha256=yW9ednji7iU9Dc_1xU5KIU6MbIzSloWVqlysy_1sLZ4,1661
+testgen/models/db_test_case.py,sha256=yQdU-4mfeVV3eSe1dN9xtF83SJcm77dJH9QbbUvZbDY,1777
+testgen/models/function.py,sha256=M-vAkvWnqxJjazT6n0xbirHNjzhrcg4pZewRvzX0PKc,1390
+testgen/models/function_metadata.py,sha256=32udGhHN1-gDy--Np1Azli-OXNLbvspyytlrVBfaQFQ,1795
+testgen/models/generator_context.py,sha256=TtPh5Td8jrEScvpwIuN2qfS31ZP8CAHL6a7vren5x4s,2462
+testgen/models/source_file.py,sha256=-o6MKvvdrlDYZX7qSuAa6F02i25F3i4ckGRQa5M5x5o,738
+testgen/models/test_case.py,sha256=jwodn-6fKHCh4SO2qycbrFyggCb9UlwTZ8k3RdTObDQ,216
+testgen/models/test_result.py,sha256=YFH84ySbhxNotnlnZCWMSLrXrrw4zaABJjrLLJzlVxE,955
+testgen/models/test_suite.py,sha256=hcKX4WSPZ7f2k_Qw24hPrkoO-_JQ49JX7E0BxatGOfg,475
+testgen/reinforcement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/reinforcement/abstract_state.py,sha256=M9Kp8fyJzsTzpyL3ca4HjjYpGXy9DRMw-IG7OgFVisY,154
+testgen/reinforcement/agent.py,sha256=lM9ZgJKQZ2_SfBG0-U0RWYwU_nyBL5Upc8yC2JbU_o0,5270
+testgen/reinforcement/environment.py,sha256=8rFSSFjnhkSvS_HSd-VC1J6iBOmoD2imsGFI-MN1fq8,6415
+testgen/reinforcement/statement_coverage_state.py,sha256=N8blj5MBO5V0oxJZLnpoWnTqK3KAu7rTm1CsltsR93M,1743
+testgen/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/service/analysis_service.py,sha256=Vl9DgxX_JcIOsIMMjEajyT_uys3DPvmlgzdwFQKvRRk,11508
+testgen/service/cfg_service.py,sha256=qjBaUFXPVMAdysx5OcWjIH0d4qOeaSijwPHYVPNglPY,2351
+testgen/service/coverage_service.py,sha256=zpbEJMU23WmfjdPfekkYdDeUKa0WZvJILfk6OYAbG_A,4573
+testgen/service/db_service.py,sha256=BiDUZni647CrePFOS4Ia-wf62j0gYKq3lsEOZphn0Pc,7081
+testgen/service/generator_service.py,sha256=CyzYIM2yp-7h05uTCuhAlPkxL6ZP3Q4N9NdZFn-kSDI,10764
+testgen/service/logging_service.py,sha256=X0HhvSFPXj08634cOfFgq_o685JTlzoNPriUZLpBpac,3195
+testgen/service/service.py,sha256=v5bfQ-mxlyBv1iQQYD06JKgU0xAWgnAVrpKKEyTizBM,14984
+testgen/service/test_executor_service.py,sha256=-37-DSQUmD4cSPC098raV8eYhHlpU11yoqNxBwSS34U,5685
+testgen/tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/tree/node.py,sha256=ONJtbACShN4yNj1X-UslFRgLyBP6mrbg7qZr3c6dWyA,165
+testgen/tree/tree_utils.py,sha256=gT7jucky6_GWVOlDI6jpv6RMeWCkntGOHIYLvHxD85k,2122
+testgen/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/util/coverage_utils.py,sha256=2jY7I3QFbIWNvpkZDl5jVCd9NJh2_fxiptbsg__MPf4,5666
+testgen/util/coverage_visualizer.py,sha256=arGU7gl5Gm0uByZrc4sGSrJ_2DdY71UG2mOU8-C_Ue0,5974
+testgen/util/file_utils.py,sha256=bfGZ8zZ6QHmnC9VkuYkDFgose586v8GokGGkidApypA,3004
+testgen/util/randomizer.py,sha256=8UqqVDk13N7SnC-8HrBi6wjl7RhAgfh2TMVN5u-ZQxk,4661
+testgen/util/utils.py,sha256=KqJsd54iD4LS0KbsBM3hS0XAdQhdCgkJmGs-bypKb6c,12212
+testgen/util/z3_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/util/z3_utils/ast_to_z3.py,sha256=V87cvlH2OlO7_owuVTqygymMmK_FyesBovi6qe-BUcg,3180
+testgen/util/z3_utils/branch_condition.py,sha256=N9FNR-iJmxIC62NpDQNVZ1OP14rXXqYzdA_NODPDUm4,2453
+testgen/util/z3_utils/constraint_extractor.py,sha256=RXJLpmk6dAvHZ27839VXKXNtdy9St1F-17-pSEFu4bM,1285
+testgen/util/z3_utils/variable_finder.py,sha256=dUh3F9_L_BDMz1ybiGss09LLcM_egbitgj0FT5Nh9u4,245
+testgen/util/z3_utils/z3_test_case.py,sha256=yF4oJOrXMLzOwDUqXdoeg83MOTl3pvc_lYaZcS01CuQ,4983
+testgenie_py-0.3.9.dist-info/METADATA,sha256=B9Hz4soDJ1VUOEPrWy_gWCwaUjpZuU95lgCbRTNTKss,4350
+testgenie_py-0.3.9.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+testgenie_py-0.3.9.dist-info/entry_points.txt,sha256=OUN4GqB4zHlHWwWGjwIPbur4E_ZqQgkeeqaCLhzRZgg,47
+testgenie_py-0.3.9.dist-info/RECORD,,

testgen/inspector/inspector.py

@@ -1,59 +0,0 @@
-from ast import FunctionType
-import inspect
-
-class Inspector:
-
-    @staticmethod
-    def get_functions(file):
-        return inspect.getmembers(file, inspect.isfunction)
-
-    @staticmethod
-    def get_signature(func: FunctionType):
-        return inspect.signature(func)
-
-    @staticmethod
-    def get_code(func: FunctionType):
-        return inspect.getsource(func)
-
-    @staticmethod
-    def get_params(sig: inspect.Signature):
-        return sig.parameters
-
-    @staticmethod
-    def get_params_not_self(sig: inspect.Signature):
-        params = sig.parameters
-        return [param for param, value in params.items() if param != 'self']
-
-    def func_inspect(self, function_name) -> list[tuple]:
-        test_cases: list[tuple] = []
-
-        functions = inspect.getmembers(function_name, inspect.isfunction)
-
-        for name, func in functions:
-            print(f"Function Name: {name}")
-            signature = inspect.signature(func)
-            print(f"Signature: {signature}")
-            for param in signature.parameters:
-                print(f"Param: {param}")
-            print(f"Function Code: {inspect.getsource(func)}")
-
-            docstring: str = inspect.getdoc(func)
-            print(f"Docstring: {docstring}")
-
-            cases: list[str] = docstring.split(",")
-
-            for case in cases:
-                io: list[str] = case.split("-")
-                input: str = io[0][7:].strip()
-                output: str = io[1][8:].strip()
-                print(f"Input: {input}")
-                print(f"Output: {output}")
-                test_cases.append((name, (input, output)))
-
-        return test_cases
-
-
-if __name__ == "__main__":
-    inspector = Inspector()
-    test_cases = inspector.func_inspect()
-    print(f"Collected Test Cases: {test_cases}")

testgen/presentation/cli_view.py

@@ -1,12 +0,0 @@
-class CLIView:
-    def __init__(self):
-        "pass"
-
-    def display_message(self, message: str):
-        print(f"[INFO] {message}")
-
-    def display_error(self, error: str):
-        print(f"[ERROR] {error}")
-
-    def prompt_input(self, prompt: str) -> str:
-        return input(f"{prompt}:> ")

testgen/sqlite/db_service.py

@@ -1,239 +0,0 @@
-import os
-import sqlite3
-import json
-import time
-import ast
-from datetime import datetime
-from typing import List, Tuple
-
-from testgen.models.test_case import TestCase
-from testgen.sqlite.db import create_database
-
-class DBService:
-    def __init__(self, db_name="testgen.db"):
-        self.db_name = db_name
-        self.conn = None
-        self.cursor = None
-        self._connect()
-
-    def _connect(self):
-        """Establish connection to the database."""
-        if not os.path.exists(self.db_name):
-            create_database(self.db_name)
-        
-        self.conn = sqlite3.connect(self.db_name)
-        self.conn.row_factory = sqlite3.Row
-        self.cursor = self.conn.cursor()
-        # Enable foreign keys
-        self.cursor.execute("PRAGMA foreign_keys = ON;")
-
-    def close(self):
-        """Close the database connection."""
-        if self.conn:
-            self.conn.close()
-            self.conn = None
-            self.cursor = None
-
-    def insert_test_suite(self, name: str) -> int:
-        """Insert a test suite and return its ID."""
-        self.cursor.execute(
-            "INSERT INTO TestSuite (name, creation_date) VALUES (?, ?)",
-            (name, datetime.now())
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def insert_source_file(self, path: str, lines_of_code: int) -> int:
-        """Insert a source file and return its ID."""
-        # Check if file already exists
-        self.cursor.execute("SELECT id FROM SourceFile WHERE path = ?", (path,))
-        existing = self.cursor.fetchone()
-        if existing:
-            return existing[0]
-        
-        self.cursor.execute(
-            "INSERT INTO SourceFile (path, lines_of_code, last_modified) VALUES (?, ?, ?)",
-            (path, lines_of_code, datetime.now())
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def insert_function(self, name: str, start_line: int, end_line: int, source_file_id: int) -> int:
-        """Insert a function and return its ID."""
-        num_lines = end_line - start_line + 1
-        
-        # Check if function already exists for this source file
-        self.cursor.execute(
-            "SELECT id FROM Function WHERE name = ? AND source_file_id = ?", 
-            (name, source_file_id)
-        )
-        existing = self.cursor.fetchone()
-        if existing:
-            return existing[0]
-            
-        self.cursor.execute(
-            "INSERT INTO Function (name, start_line, end_line, num_lines, source_file_id) VALUES (?, ?, ?, ?, ?)",
-            (name, start_line, end_line, num_lines, source_file_id)
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def insert_test_case(self, test_case: TestCase, test_suite_id: int, function_id: int, test_method_type: int) -> int:
-        """Insert a test case and return its ID."""
-        # Convert inputs and expected output to JSON strings
-        inputs_json = json.dumps(test_case.inputs)
-        expected_json = json.dumps(test_case.expected)
-        
-        self.cursor.execute(
-            "INSERT INTO TestCase (name, expected_output, input, test_function, last_run_time, test_method_type, test_suite_id, function_id) "
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            (
-                f"test_{test_case.func_name}",
-                expected_json,
-                inputs_json,
-                test_case.func_name,
-                datetime.now(),
-                test_method_type,
-                test_suite_id,
-                function_id
-            )
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def insert_test_result(self, test_case_id: int, status: bool, error: str = None) -> int:
-        """Insert a test result and return its ID."""
-        self.cursor.execute(
-            "INSERT INTO TestResult (test_case_id, status, error, execution_time) VALUES (?, ?, ?, ?)",
-            (test_case_id, status, error, datetime.now())
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def insert_coverage_data(self, file_name: str, executed_lines: str, missed_lines: str,
-                           branch_coverage: float, source_file_id: int) -> int:
-        """Insert coverage data and return its ID."""
-        self.cursor.execute(
-            "INSERT INTO CoverageData (file_name, executed_lines, missed_lines, branch_coverage, source_file_id) "
-            "VALUES (?, ?, ?, ?, ?)",
-            (file_name, executed_lines, missed_lines, branch_coverage, source_file_id)
-        )
-        self.conn.commit()
-        return self.cursor.lastrowid
-
-    def save_test_generation_data(self, file_path: str, test_cases: List[TestCase], 
-                                test_method_type: int, class_name: str = None) -> Tuple[int, List[int]]:
-        """
-        Save all data related to a test generation run.
-        Returns the test suite ID and a list of test case IDs.
-        """
-        # Count lines in the source file
-        with open(file_path, 'r') as f:
-            lines_of_code = len(f.readlines())
-        
-        # Create test suite
-        strategy_names = {1: "AST", 2: "Fuzz", 3: "Random", 4: "Reinforcement"}
-        suite_name = f"{strategy_names.get(test_method_type, 'Unknown')}_Suite_{int(time.time())}"
-        test_suite_id = self.insert_test_suite(suite_name)
-        
-        # Insert source file
-        source_file_id = self.insert_source_file(file_path, lines_of_code)
-        
-        # Process functions and test cases
-        test_case_ids = []
-        function_ids = {}  # Cache function IDs to avoid redundant queries
-        
-        for test_case in test_cases:
-            # Extract function name from test case
-            func_name = test_case.func_name
-            
-            # If function not already processed
-            if func_name not in function_ids:
-                # Get function line numbers
-                start_line, end_line = self._get_function_line_numbers(file_path, func_name)
-                function_id = self.insert_function(func_name, start_line, end_line, source_file_id)
-                function_ids[func_name] = function_id
-            
-            # Insert test case
-            test_case_id = self.insert_test_case(
-                test_case, 
-                test_suite_id, 
-                function_ids[func_name], 
-                test_method_type
-            )
-            test_case_ids.append(test_case_id)
-        
-        return test_suite_id, test_case_ids
-    
-    def _get_function_line_numbers(self, file_path: str, function_name: str) -> Tuple[int, int]:
-        """
-        Extract the start and end line numbers for a function in a file.
-        Returns a tuple of (start_line, end_line).
-        """
-        try:
-            # Load the file and parse it
-            with open(file_path, 'r') as f:
-                file_content = f.read()
-                
-            tree = ast.parse(file_content)
-            
-            # Find the function definition
-            for node in ast.walk(tree):
-                if isinstance(node, ast.FunctionDef) and node.name == function_name:
-                    end_line = node.end_lineno if hasattr(node, 'end_lineno') else node.lineno + 5  # Estimate if end_lineno not available
-                    return node.lineno, end_line
-                    
-            # Also look for class methods
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    for class_node in node.body:
-                        if isinstance(class_node, ast.FunctionDef) and class_node.name == function_name:
-                            end_line = class_node.end_lineno if hasattr(class_node, 'end_lineno') else class_node.lineno + 5
-                            return class_node.lineno, end_line
-        except Exception as e:
-            print(f"Error getting function line numbers: {e}")
-            
-        # If we reach here, the function wasn't found or there was an error
-        return 0, 0
-    
-    def get_test_suites(self):
-        """Get all test suites from the database."""
-        self.cursor.execute("SELECT * FROM TestSuite ORDER BY creation_date DESC")
-        return self.cursor.fetchall()
-    
-    def get_test_cases_by_function(self, function_name):
-        """Get all test cases for a specific function."""
-        self.cursor.execute(
-            "SELECT tc.* FROM TestCase tc JOIN Function f ON tc.function_id = f.id WHERE f.name = ?",
-            (function_name,)
-        )
-        return self.cursor.fetchall()
-    
-    def get_coverage_by_file(self, file_path):
-        """Get coverage data for a specific file."""
-        self.cursor.execute(
-            "SELECT cd.* FROM CoverageData cd JOIN SourceFile sf ON cd.source_file_id = sf.id WHERE sf.path = ?", 
-            (file_path,)
-        )
-        return self.cursor.fetchall()
-
-    def get_test_file_data(self, file_path: str):
-        """
-        Retrieve all test cases, coverage data, and test results for a specific file.
-        """
-        query = """
-            SELECT
-                tc.id AS test_case_id,
-                tc.name AS test_case_name,
-                tc.test_function AS test_case_test_function,
-                tc.test_method_type AS test_case_method_type,
-                COALESCE(cd.missed_lines, 'None') AS coverage_data_missed_lines
-            FROM SourceFile sf
-            LEFT JOIN Function f ON sf.id = f.source_file_id
-            LEFT JOIN TestCase tc ON f.id = tc.function_id
-            LEFT JOIN TestResult tr ON tc.id = tr.test_case_id
-            LEFT JOIN CoverageData cd ON sf.id = cd.source_file_id
-            WHERE sf.path = ?;
-        """
-        self.cursor.execute(query, (file_path,))
-        return self.cursor.fetchall()