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

testgen/analyzer/ast_analyzer.py

@@ -53,17 +53,8 @@ class ASTAnalyzer(TestCaseAnalyzerStrategy, ABC):
                     
                 if not input_exists:
                     try:
-                        generated_file = function_metadata.filename
-                        module = testgen.util.file_utils.load_module(generated_file)
-                        
-                        if function_metadata.class_name:
-                            cls = getattr(module, function_metadata.class_name)
-                            instance = cls()
-                            func = getattr(instance, func_name)
-                            output = func(*inputs)
-                        else:
-                            func = getattr(module, func_name)
-                            output = func(*inputs)
+                        func = function_metadata.func
+                        output = func(*inputs)
                         
                     except Exception as e:
                         print(f"Error executing function: {e}")

testgen/analyzer/fuzz_analyzer.py

@@ -29,13 +29,8 @@ class FuzzAnalyzer(TestCaseAnalyzerStrategy, ABC):
         else:
             raise ValueError("Module not set in function metadata. Cannot perform fuzzing without a module.")
             
-        class_name = function_metadata.class_name if function_metadata.class_name else None
         try:
-            if not class_name is None:
-                cls = getattr(module, class_name, None)
-                func = getattr(cls(), function_metadata.function_name, None) if cls else None
-            else:
-                func = getattr(module, function_metadata.function_name, None)
+            func = function_metadata.func
             if func:
                 return self.run_fuzzing(func, function_metadata.function_name, function_metadata.params, module, 10)
         except Exception as e:

testgen/analyzer/random_feedback_analyzer.py

@@ -1,13 +1,7 @@
-import ast
-import importlib
 import random
 import time
 import traceback
 from typing import List, Dict, Set
-import z3
-
-import testgen.util.randomizer
-import testgen.util.utils as utils
 import testgen.util.coverage_utils as coverage_utils
 from testgen.analyzer.contracts.contract import Contract
 from testgen.analyzer.contracts.no_exception_contract import NoExceptionContract
@@ -17,8 +11,6 @@ from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
 from abc import ABC
 
 from testgen.models.function_metadata import FunctionMetadata
-from testgen.util.z3_utils.constraint_extractor import extract_branch_conditions
-from testgen.util.z3_utils.ast_to_z3 import ast_to_z3_constraint
 
 
 # Citation in which this method and algorithm were taken from:
@@ -42,26 +34,12 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
             
             try:
                 param_values = self.generate_random_inputs(function_metadata.params)
-                module = self.analysis_context.module
                 func_name = function_metadata.function_name
+                function = function_metadata.func
                 
-                if self._analysis_context.class_name:
-                    cls = getattr(module, self._analysis_context.class_name)
-                    obj = cls()
-                    function = getattr(obj, func_name)
-                else:
-                    function = getattr(module, func_name)
-                
-                import inspect
-                sig = inspect.signature(function)
-                param_names = [p.name for p in sig.parameters.values() if p.name != 'self']
+                param_names = function_metadata.params.keys()
                 
-                ordered_args = []
-                for name in param_names:
-                    if name in param_values:
-                        ordered_args.append(param_values[name])
-                    else:
-                        ordered_args.append(None)
+                ordered_args = [param_values.get(name, None) for name in param_names]
                 
                 result = function(*ordered_args)
                 test_case = TestCase(func_name, tuple(ordered_args), result)
@@ -92,14 +70,16 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
         if func.function_name not in self.covered_lines:
             self.covered_lines[func.function_name] = set()
 
-        for test_case in [tc for tc in self.test_cases if tc.func_name == func.function_name]:
-            analysis = coverage_utils.get_coverage_analysis(self._analysis_context.filepath, self._analysis_context.class_name,
-                                                                         func.function_name, test_case.inputs)
+        test_cases = [tc for tc in self.test_cases if tc.func_name == func.function_name]
+
+        for test_case in test_cases:
+            analysis = coverage_utils.get_coverage_analysis(self._analysis_context.filepath, func, test_case.inputs)
             covered = coverage_utils.get_list_of_covered_statements(analysis)
             self.covered_lines[func.function_name].update(covered)
             self.logger.debug(f"Covered lines for {func.function_name}: {self.covered_lines[func.function_name]}")
 
-        executable_statements = set(self.get_all_executable_statements(func))
+
+        executable_statements = set(coverage_utils.get_all_executable_statements(self._analysis_context.filepath, func, test_cases))
         self.logger.debug(f"Executable statements for {func.function_name}: {executable_statements}")
 
         return self.covered_lines[func.function_name] == executable_statements
@@ -107,34 +87,14 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
     def execute_sequence(self, sequence, contracts: List[Contract]):
         """Execute a sequence and check contract violations"""
         func_name, args_dict = sequence
-        args = tuple(args_dict.values())  # Convert dict values to tuple
 
         try:
             # Use module from analysis context if available
-            module = self.analysis_context.module
-
-            if self._analysis_context.class_name:
-                cls = getattr(module, self._analysis_context.class_name, None)
-                if cls is None:
-                    raise AttributeError(f"Class '{self._analysis_context.class_name}' not found")
-                obj = cls()  # Instantiate the class
-                func = getattr(obj, func_name, None)
-
-                import inspect
-                sig = inspect.signature(func)
-                param_names = [p.name for p in sig.parameters.values() if p.name != 'self']
-            else:
-                func = getattr(module, func_name, None)
-
-                import inspect
-                sig = inspect.signature(func)
-                param_names = [p.name for p in sig.parameters.values()]
+            function_metadata = self.get_function_metadata(func_name)
+            func = function_metadata.func
+            param_names = function_metadata.params.keys()
 
-            # Create ordered arguments based on function signature
-            ordered_args = []
-            for name in param_names:
-                if name in args_dict:
-                    ordered_args.append(args_dict[name])
+            ordered_args = [args_dict.get(name, None) for name in param_names]
 
             # Check preconditions
             for contract in contracts:
@@ -159,26 +119,17 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
                 return output, True
 
         return output, False
-    
+
+    def get_function_metadata(self, func_name: str) -> FunctionMetadata | None:
+        for function_data in self._analysis_context.function_data:
+            if function_data.function_name == func_name:
+                return function_data
+        return None
 
     # TODO: Currently only getting random vals of primitives, extend to sequences
     def random_seqs_and_vals(self, param_types, non_error_seqs=None):
         return self.generate_random_inputs(param_types)
 
-    @staticmethod
-    def extract_parameter_types(func_node):
-        """Extract parameter types from a function node."""
-        param_types = {}
-        for arg in func_node.args.args:
-            param_name = arg.arg
-            if arg.annotation:
-                param_type = ast.unparse(arg.annotation)
-                param_types[param_name] = param_type
-            else:
-                if param_name != 'self':
-                    param_types[param_name] = None
-        return param_types
-
     @staticmethod
     def generate_random_inputs(param_types):
         """Generate inputs for fuzzing based on parameter types."""
@@ -294,228 +245,4 @@ class RandomFeedbackAnalyzer(TestCaseAnalyzerStrategy, ABC):
                 break
 
         self.test_cases.sort(key=lambda tc: tc.func_name)
-        return error_seqs, non_error_seqs
-    
-    def get_all_executable_statements(self, func: FunctionMetadata):
-        import ast
-
-        test_cases = [tc for tc in self.test_cases if tc.func_name == func.function_name]
-
-        if not test_cases:
-            print("Warning: No test cases available to determine executable statements")
-            from testgen.util.randomizer import new_random_test_case
-            temp_case = new_random_test_case(self._analysis_context.filepath, func.func_def)
-            analysis = coverage_utils.get_coverage_analysis(self._analysis_context.filepath, self._analysis_context.class_name, func.function_name,
-                                                                         temp_case.inputs)
-        else:
-            analysis = coverage_utils.get_coverage_analysis(self._analysis_context.filepath, self._analysis_context.class_name, func.function_name, test_cases[0].inputs)
-
-        executable_lines = list(analysis[1])
-
-        with open(self._analysis_context.filepath, 'r') as f:
-            source = f.read()
-
-        tree = ast.parse(source)
-
-        for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef) and node.name == func.func_def.name:
-                for if_node in ast.walk(node):
-                    if isinstance(if_node, ast.If) and if_node.orelse:
-                        if isinstance(if_node.orelse[0], ast.If):
-                            continue
-                        else_line = if_node.orelse[0].lineno - 1
-
-                        with open(self._analysis_context.filepath, 'r') as f:
-                            lines = f.readlines()
-                            if else_line <= len(lines):
-                                line_content = lines[else_line - 1].strip()
-                                if line_content == "else:":
-                                    if else_line not in executable_lines:
-                                        executable_lines.append(else_line)
-
-        return sorted(executable_lines)
-
-    """
-    def collect_test_cases_with_z3(self, function_metadata: FunctionMetadata) -> List[TestCase]:
-        test_cases = []
-        
-        z3_test_cases = self.generate_z3_test_cases(function_metadata)
-        if z3_test_cases:
-            test_cases.extend(z3_test_cases)
-        
-        if not test_cases:
-            test_cases = self.generate_sequences_new()[1]
-        
-        self.test_cases = test_cases
-        return test_cases
-
-    def generate_z3_test_cases(self, function_metadata: FunctionMetadata) -> List[TestCase]:
-        test_cases = []
-        
-        branch_conditions, param_types = extract_branch_conditions(function_metadata.func_def)
-        
-        if not branch_conditions:
-            random_inputs = self.generate_random_inputs(function_metadata.params)
-            try:
-                module = self.analysis_context.module
-                func_name = function_metadata.function_name
-                
-                if self._analysis_context.class_name:
-                    cls = getattr(module, self._analysis_context.class_name)
-                    obj = cls()
-                    func = getattr(obj, func_name)
-                    ordered_args = self._order_arguments(func, random_inputs)
-                    output = func(*ordered_args)
-                else:
-                    func = getattr(module, func_name)
-                    ordered_args = self._order_arguments(func, random_inputs)
-                    output = func(*ordered_args)
-                
-                test_cases.append(TestCase(func_name, tuple(ordered_args), output))
-            except Exception as e:
-                print(f"Error executing function with random inputs: {e}")
-            
-            return test_cases
-        
-        for branch_condition in branch_conditions:
-            try:
-                z3_expr, z3_vars = ast_to_z3_constraint(branch_condition, function_metadata.params)
-                
-                solver = z3.Solver()
-                solver.add(z3_expr)
-                
-                neg_solver = z3.Solver()
-                neg_solver.add(z3.Not(z3_expr))
-                
-                for current_solver in [solver, neg_solver]:
-                    if current_solver.check() == z3.sat:
-                        model = current_solver.model()
-                        
-                        param_values = self._extract_z3_solution(model, z3_vars, function_metadata.params)
-                        
-                        ordered_params = self._order_parameters(function_metadata.func_def, param_values)
-                        
-                        try:
-                            module = self.analysis_context.module
-                            func_name = function_metadata.function_name
-                            
-                            if self._analysis_context.class_name:
-                                cls = getattr(module, self._analysis_context.class_name)
-                                obj = cls()
-                                func = getattr(obj, func_name)
-                            else:
-                                func = getattr(module, func_name)
-                                
-                            result = func(*ordered_params)
-                            test_cases.append(TestCase(func_name, tuple(ordered_params), result))
-                        except Exception as e:
-                            print(f"Error executing function with Z3 solution: {e}")
-                            self._add_random_test_case(function_metadata, test_cases)
-                    else:
-                        self._add_random_test_case(function_metadata, test_cases)
-                        
-            except Exception as e:
-                print(f"Error processing branch condition with Z3: {e}")
-                self._add_random_test_case(function_metadata, test_cases)
-        
-        return test_cases
-    
-    def _extract_z3_solution(self, model, z3_vars, param_types):
-        param_values = {}
-        
-        for var_name, z3_var in z3_vars.items():
-            if var_name in param_types:
-                try:
-                    model_value = model.evaluate(z3_var)
-                    
-                    if param_types[var_name] == "int":
-                        param_values[var_name] = model_value.as_long()
-                    elif param_types[var_name] == "float":
-                        param_values[var_name] = float(model_value.as_decimal(10))
-                    elif param_types[var_name] == "bool":
-                        param_values[var_name] = z3.is_true(model_value)
-                    elif param_types[var_name] == "str":
-                        str_val = str(model_value)
-                        if str_val.startswith('"') and str_val.endswith('"'):
-                            str_val = str_val[1:-1]
-                        param_values[var_name] = str_val
-                    else:
-                        # Default to int for unrecognized types
-                        param_values[var_name] = model_value.as_long()
-                except Exception as e:
-                    print(f"Couldn't get {var_name} from model: {e}")
-                    # Use default values for parameters not in the model
-                    if param_types[var_name] == "int":
-                        param_values[var_name] = 0
-                    elif param_types[var_name] == "float":
-                        param_values[var_name] = 0.0
-                    elif param_types[var_name] == "bool":
-                        param_values[var_name] = False
-                    elif param_types[var_name] == "str":
-                        param_values[var_name] = ""
-                    else:
-                        param_values[var_name] = None
-        
-        return param_values
-    
-    def _order_parameters(self, func_node, param_values):
-        ordered_params = []
-        
-        for arg in func_node.args.args:
-            arg_name = arg.arg
-            if arg_name == 'self':  # Skip self parameter
-                continue
-            if arg_name in param_values:
-                ordered_params.append(param_values[arg_name])
-            else:
-                # Default value handling if parameter not in solution
-                if arg.annotation and hasattr(arg.annotation, 'id'):
-                    if arg.annotation.id == 'int':
-                        ordered_params.append(0)
-                    elif arg.annotation.id == 'float':
-                        ordered_params.append(0.0)
-                    elif arg.annotation.id == 'bool':
-                        ordered_params.append(False)
-                    elif arg.annotation.id == 'str':
-                        ordered_params.append('')
-                    else:
-                        ordered_params.append(None)
-                else:
-                    ordered_params.append(None)
-        
-        return ordered_params
-    
-    def _order_arguments(self, func, args_dict):
-        import inspect
-        sig = inspect.signature(func)
-        param_names = [p.name for p in sig.parameters.values() if p.name != 'self']
-        
-        ordered_args = []
-        for name in param_names:
-            if name in args_dict:
-                ordered_args.append(args_dict[name])
-            else:
-                ordered_args.append(None)  # Default to None if missing
-        
-        return ordered_args
-    
-    def _add_random_test_case(self, function_metadata, test_cases):
-        random_inputs = self.generate_random_inputs(function_metadata.params)
-        try:
-            module = self.analysis_context.module
-            func_name = function_metadata.function_name
-            
-            if self._analysis_context.class_name:
-                cls = getattr(module, self._analysis_context.class_name)
-                obj = cls()
-                func = getattr(obj, func_name)
-            else:
-                func = getattr(module, func_name)
-            
-            ordered_args = self._order_arguments(func, random_inputs)
-            
-            output = func(*ordered_args)
-            test_cases.append(TestCase(func_name, tuple(ordered_args), output))
-        except Exception as e:
-            print(f"Error executing function with random inputs: {e}")
-    """
+        return error_seqs, non_error_seqs

testgen/analyzer/reinforcement_analyzer.py

@@ -5,6 +5,7 @@ import random
 from typing import List
 
 import testgen.util.randomizer
+from testgen.models.function_metadata import FunctionMetadata
 from testgen.models.test_case import TestCase
 from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
 from testgen.reinforcement.environment import ReinforcementEnvironment
@@ -16,60 +17,61 @@ from testgen.reinforcement.environment import ReinforcementEnvironment
 # Actions: Create new test case, combine test cases, delete test cases
 # Rewards:
 
-# Maybe consider the state as number of branches covered in a function possibly considering it the same state
-
-class ReinforcementAnalyzer(TestCaseAnalyzerStrategy, ABC):
-    def __init__(self, module, class_name: str, env: ReinforcementEnvironment):
-        super().__init__(module, class_name)
-        self.env = env # includes file name, module/fut, coverage, and test cases
-        self.q_table = {} # Dictionary of key: state, action pairs and value: q-value
-        self.actions = ["add", "merge", "remove"] # three possible actions
-
-    def collect_test_cases(self, func_node: ast.FunctionDef) -> List[TestCase]:
-        self.env.test_cases.append(testgen.util.randomizer.new_random_test_case(f"{self._module.__name__}.py", func_node))
-        return self.env.test_cases
-
-    def set_env(self, env: ReinforcementEnvironment):
-        self.env = env
-
-    def refine_test_cases(self, func: ast.FunctionDef) -> List[TestCase]:
-        state = self.env.get_state() # Should return state as Tuple(List[TestCase], coverage)
-
-        if not isinstance(state, tuple) or len(state) != 2:
-            raise ValueError(f"Expected state to be a tuple (test_cases, coverage_score), but got: {state}")
-
-        action = self.choose_action(state)
-        new_state, reward = self.env.step(action)
-
-        if not isinstance(new_state, tuple) or len(new_state) != 2:
-            raise ValueError(f"Expected new_state to be a tuple (test_cases, coverage_score), but got: {new_state}")
-
-        print(f"AFTER NEW STATE, REWARD: {reward}")
-
-        self.update_q_table(state, action, reward, new_state)
-
-        return self.env.test_cases
-
-    def choose_action(self, state):
-        choice = random.choice(["EXPLORATION", "EXPLOITATION"])
-        test_cases, coverage_score = state  # Unpack state properly
-        state_key = (tuple((tc.func_name, tc.inputs, tc.expected) for tc in test_cases), coverage_score)
-
-        if choice == "EXPLORATION":
-            return random.choice(self.actions)
-        else:
-            # Is going to try to pick the highest value in the q_table with the state_key and action pair
-            # Is probably always going to be 0 unless we have the same exact test cases and coverage as represented in the state key
-            return max(self.actions, key=lambda action: self.q_table.get((state_key, action), 0), default=random.choice(self.actions))
-
-    def update_q_table(self, state, action, reward, next_state):
-        test_cases, coverage_score = state
-        next_test_cases, next_coverage_score = next_state
-
-        state_key = (tuple((tc.func_name, tc.inputs, tc.expected) for tc in test_cases), coverage_score)
-        next_state_key = (tuple((tc.func_name, tc.inputs, tc.expected) for tc in next_test_cases), next_coverage_score)
-
-        print("HERE UPDATE TABLE")
-        old_q = self.q_table.get((state_key, action), 0)
-        future_q = max(self.q_table.get((next_state_key, a), 0) for a in self.actions)
-        self.q_table[(state_key, action)] = old_q * (reward + future_q)
+from typing import List, Optional
+from testgen.models.test_case import TestCase
+from testgen.models.analysis_context import AnalysisContext
+from testgen.analyzer.test_case_analyzer import TestCaseAnalyzerStrategy
+from testgen.reinforcement.agent import ReinforcementAgent
+from testgen.reinforcement.environment import ReinforcementEnvironment
+from testgen.reinforcement.statement_coverage_state import StatementCoverageState
+
+
+class ReinforcementAnalyzer(TestCaseAnalyzerStrategy):
+    def __init__(self, analysis_context: AnalysisContext, mode: str = "train"):
+        super().__init__(analysis_context)
+        self.analysis_context = analysis_context
+        self.mode = mode
+
+    def collect_test_cases(self, function_metadata: FunctionMetadata):
+        # Implement or delegate as needed
+        return self.analyze(function_metadata)
+
+    def analyze(self, function_metadata: FunctionMetadata) -> List[TestCase]:
+        from testgen.service.analysis_service import AnalysisService
+
+        q_table = AnalysisService._load_q_table()
+        function_test_cases: List[TestCase] = []
+
+
+        environment = ReinforcementEnvironment(
+            self.analysis_context.filepath,
+            function_metadata,
+            function_test_cases,
+            state=StatementCoverageState(None)
+        )
+        environment.state = StatementCoverageState(environment)
+        agent = ReinforcementAgent(
+            self.analysis_context.filepath,
+            environment,
+            function_test_cases,
+            q_table
+        )
+        episodes = 10 if self.mode == "train" else 1
+        for _ in range(episodes):
+            if self.mode == "train":
+                new_test_cases = agent.do_q_learning()
+            else:
+                new_test_cases = agent.collect_test_cases()
+            function_test_cases.extend(new_test_cases)
+
+        seen = set()
+        unique_test_cases = []
+        for case in function_test_cases:
+            case_inputs = tuple(case.inputs) if isinstance(case.inputs, list) else case.inputs
+            case_key = (case.func_name, case_inputs)
+            if case_key not in seen:
+                seen.add(case_key)
+                unique_test_cases.append(case)
+
+        AnalysisService._save_q_table(q_table)
+        return unique_test_cases

testgen/analyzer/test_case_analyzer_context.py

@@ -11,12 +11,6 @@ class TestCaseAnalyzerContext:
         self._test_case_analyzer = test_case_analyzer
         self._analysis_context = analysis_context
         self._test_cases = []
-        
-    # TODO: GET RID OF THIS STUPID METHOD IT IS POINTLESS
-    # JUST CALL INSIDE ANALYZER_SERVICE
-    def do_logic(self) -> List[TestCase]:
-        """Run the analysis process"""
-        self.do_strategy(20)
 
     def do_strategy(self, time_limit=None) -> List[TestCase]:
         """Execute the analysis strategy for all functions with an optional time limit"""