testgenie-py 0.1.0__py3-none-any.whl

testgen/util/utils.py

@@ -0,0 +1,143 @@
+
+import ast
+import string
+import sys
+import random
+from typing import List
+
+from atheris import FuzzedDataProvider
+
+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 = {}
+    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
+
+def generate_random_inputs(param_types):
+    """Generate inputs for fuzzing based on parameter types."""
+    inputs = {}
+    for param, param_type in param_types.items():
+        if param_type == "int":
+            # Try using sys.maxsize for minsize and maxsize
+            minsize = -sys.maxsize - 1
+            maxsize = sys.maxsize
+            random_integer = random.randint(minsize, maxsize)
+            inputs[param] = random_integer
+        elif param_type == "bool":
+            random_choice = random.choice([True, False])
+            inputs[param] = random_choice
+        elif param_type == "float":
+            random_float = random.random()
+            inputs[param] = random_float
+        # TODO: Random String and Random bytes; Random objects?
+        elif param_type == "str":
+            inputs[param] = "abc"
+        #elif param_type == "bytes":
+        #    inputs[param] = fdp.ConsumeBytes(10)
+        else:
+            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:
+        if isinstance(node, ast.FunctionDef):
+            functions.append(node)
+        if isinstance(node, ast.ClassDef):
+            for class_node in node.body:
+                if isinstance(class_node, ast.FunctionDef):
+                    functions.append(class_node)
+    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):
+        if isinstance(node, ast.FunctionDef) and node.name == func_name:
+            func_start = node.lineno
+
+            if i == len(tree.body) - 1:
+                max_lines = [line.lineno for line in ast.walk(node) if hasattr(line, 'lineno') and line.lineno]
+                func_end = max(max_lines) if max_lines else func_start
+            else:
+                next_node = tree.body[i + 1]
+                if hasattr(next_node, 'lineno'):
+                    func_end = next_node.lineno - 1
+                else:
+                    max_lines = [line.lineno for line in ast.walk(node) if hasattr(line, 'lineno') and line.lineno]
+                    func_end = max(max_lines) if max_lines else func_start
+
+            return func_start, func_end
+        
+    # For classes
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            for i, method in enumerate(node.body):
+                if isinstance(method, ast.FunctionDef) and method.name == func_name:
+                    func_start = method.lineno
+                    
+                    # Find end of method
+                    if i == len(node.body) - 1:
+                        max_lines = [line.lineno for line in ast.walk(method) 
+                                     if hasattr(line, 'lineno') and line.lineno]
+                        func_end = max(max_lines) if max_lines else func_start
+                    else:
+                        next_method = node.body[i + 1]
+                        if hasattr(next_method, 'lineno'):
+                            func_end = next_method.lineno - 1
+                        else:
+                            max_lines = [line.lineno for line in ast.walk(method)
+                                         if hasattr(line, 'lineno') and line.lineno]
+                            func_end = max(max_lines) if max_lines else func_start
+                    
+                    return func_start, func_end
+    
+    raise ValueError(f"Function {func_name} not found in {file_name}")
+
+    
+

testgen/util/z3_utils/ast_to_z3.py

@@ -0,0 +1,99 @@
+import ast
+from typing import Dict
+import z3
+
+class ASTToZ3(ast.NodeVisitor):
+    def __init__(self, param_types: Dict[str, str]):
+        self.param_types = param_types
+        self.z3_vars = {}
+
+    def create_z3_var(self, name: str, type_hint: str = None):
+        if name in self.z3_vars:
+            return self.z3_vars[name]
+        
+        if type_hint == "int" or type_hint is None:
+            z3_var = z3.Int(name)
+        elif type_hint == "float":
+            z3_var = z3.Real(name)
+        elif type_hint == "bool":
+            z3_var = z3.Bool(name)
+        elif type_hint == "str":
+            z3_var = z3.String(name)
+        else:
+            z3_var = z3.Int(name)
+
+        self.z3_vars[name] = z3_var
+        return z3_var
+    
+    def visit_Name(self, node):
+        if node.id in self.param_types:
+            return self.create_z3_var(node.id, self.param_types[node.id])
+        return self.create_z3_var(node.id)
+    
+    def visit_Constant(self, node):
+        return node.value
+    
+    def visit_BinOp(self, node):
+        left = self.visit(node.left)
+        right = self.visit(node.right)
+        
+        if isinstance(node.op, ast.Add):
+            return left + right
+        elif isinstance(node.op, ast.Sub):
+            return left - right
+        elif isinstance(node.op, ast.Mult):
+            return left * right
+        elif isinstance(node.op, ast.Div):
+            return left / right
+        elif isinstance(node.op, ast.Mod):
+            return left % right
+        else:
+            raise NotImplementedError(f"Operation {node.op} not implemented")
+        
+    def visit_Compare(self, node):
+        left = self.visit(node.left)
+
+        result = None
+        for i, (op, right) in enumerate(zip(node.ops, node.comparators)):
+            right_val = self.visit(right)
+            
+            if isinstance(op, ast.Eq):
+                condition = left == right_val
+            elif isinstance(op, ast.NotEq):
+                condition = left != right_val
+            elif isinstance(op, ast.Lt):
+                condition = left < right_val
+            elif isinstance(op, ast.LtE):
+                condition = left <= right_val
+            elif isinstance(op, ast.Gt):
+                condition = left > right_val
+            elif isinstance(op, ast.GtE):
+                condition = left >= right_val
+
+            if result is None:
+                result = condition
+            else:
+                result = z3.And(result, condition)
+
+        return result
+    
+    def visit_BoolOp(self, node):
+        values = [self.visit(value) for value in node.values]
+
+        if isinstance(node.op, ast.And):
+            return z3.And(*values)
+        elif isinstance(node.op, ast.Or):
+            return z3.Or(*values)
+        else:
+            raise NotImplementedError(f"Operation {node.op} not implemented")
+        
+    def convert(self, ast_node):
+        return self.visit(ast_node)
+    
+def ast_to_z3_constraint(branch_condition, param_types):
+    converter = ASTToZ3(param_types)
+    z3_expr = converter.convert(branch_condition.condition_ast)
+    branch_condition.z3_expr = z3_expr
+    return z3_expr, converter.z3_vars
+    
+    

testgen/util/z3_utils/branch_condition.py

@@ -0,0 +1,72 @@
+import ast
+
+class BranchCondition:
+    def __init__(self, condition_ast, line_number, variables):
+        self._condition_ast = condition_ast
+        self._line_number = line_number
+        self._variables = variables
+        self._z3_expr = None
+        
+    @property
+    def condition_ast(self):
+        """Get the AST node representing the condition"""
+        return self._condition_ast
+    
+    @condition_ast.setter
+    def condition_ast(self, value):
+        """Set the AST node representing the condition"""
+        self._condition_ast = value
+    
+    @property
+    def line_number(self):
+        """Get the line number where this condition appears"""
+        return self._line_number
+    
+    @line_number.setter
+    def line_number(self, value):
+        """Set the line number where this condition appears"""
+        self._line_number = value
+    
+    @property
+    def variables(self):
+        """Get the variables used in this condition"""
+        return self._variables
+    
+    @variables.setter
+    def variables(self, value):
+        """Set the variables used in this condition"""
+        self._variables = value
+    
+    @property
+    def z3_expr(self):
+        """Get the Z3 expression for this condition"""
+        return self._z3_expr
+    
+    @z3_expr.setter
+    def z3_expr(self, value):
+        """Set the Z3 expression for this condition"""
+        self._z3_expr = value
+    
+    def __str__(self):
+        """Return a string representation of this branch condition"""
+        condition_text = ast.unparse(self.condition_ast) if self.condition_ast else "None"
+        vars_text = ", ".join(sorted(self.variables)) if self.variables else "None"
+        z3_text = str(self.z3_expr) if self.z3_expr else "None"
+        
+        return (f"BranchCondition(line={self.line_number}, "
+                f"condition='{condition_text}', "
+                f"variables=[{vars_text}], "
+                f"z3_expr={z3_text})")
+    
+    def __repr__(self):
+        """Return a string representation for debugging"""
+        return self.__str__()
+    
+    def to_dict(self):
+        """Convert this branch condition to a dictionary"""
+        return {
+            'line_number': self.line_number,
+            'condition': ast.unparse(self.condition_ast) if self.condition_ast else None,
+            'variables': sorted(list(self.variables)) if self.variables else [],
+            'z3_expr': str(self.z3_expr) if self.z3_expr else None
+        }

testgen/util/z3_utils/constraint_extractor.py

@@ -0,0 +1,36 @@
+import ast
+from _ast import FunctionDef
+from typing import List, Tuple
+from testgen.util.z3_utils.branch_condition import BranchCondition
+from testgen.util.z3_utils.variable_finder import VariableFinder
+
+class ConstraintExtractor(ast.NodeVisitor):
+    def __init__(self):
+        self.branch_conditions = []
+        self.current_function = None
+        self.param_types = {}
+
+    def visit_FunctionDef(self, node: FunctionDef):
+        prev_function = self.current_function
+        self.current_function = node.name
+
+        for arg in node.args.args:
+            if arg.arg != 'self' and arg.annotation:
+                self.param_types[arg.arg] = ast.unparse(arg.annotation)
+        
+        self.generic_visit(node)
+        self.current_function = prev_function
+
+    def visit_If(self, node):
+        variable_finder = VariableFinder()
+        variable_finder.visit(node.test)
+        variables = variable_finder.variables
+
+        self.branch_conditions.append(BranchCondition(node.test, node.test.lineno, variables))
+
+        self.generic_visit(node)
+
+def extract_branch_conditions(func_node: ast.FunctionDef) -> Tuple[List[BranchCondition], dict]:
+    extractor = ConstraintExtractor()
+    extractor.visit(func_node)
+    return extractor.branch_conditions, extractor.param_types

testgen/util/z3_utils/variable_finder.py

@@ -0,0 +1,10 @@
+import ast
+from typing import List
+
+class VariableFinder(ast.NodeVisitor):
+    def __init__(self):
+        self.variables = set()
+
+    def visit_Name(self, node):
+        if isinstance(node.ctx, ast.Load):
+            self.variables.add(node.id)

testgen/util/z3_utils/z3_test_case.py

@@ -0,0 +1,94 @@
+import ast
+from typing import List
+
+import z3
+
+import testgen.util.file_utils
+from testgen.models.test_case import TestCase
+from testgen.util.z3_utils import ast_to_z3
+from testgen.util.z3_utils.constraint_extractor import extract_branch_conditions
+
+
+def solve_branch_condition(file_name: str, func_node: ast.FunctionDef, uncovered_lines: List[int]) -> List[TestCase]:
+    branch_conditions, param_types = extract_branch_conditions(func_node)
+    uncovered_conditions = [bc for bc in branch_conditions if bc.line_number in uncovered_lines]
+    test_cases = []
+
+    for branch_condition in uncovered_conditions:
+        z3_expr, z3_vars = ast_to_z3.ast_to_z3_constraint(branch_condition, param_types)
+        solver = z3.Solver()
+        solver.add(z3_expr)
+
+        if solver.check() == z3.sat:
+            model = solver.model()
+
+            # Create default values for all parameters
+            param_values = {}
+            for param_name in param_types:
+                # Set default values based on type
+                if param_types[param_name] == "int":
+                    param_values[param_name] = 0
+                elif param_types[param_name] == "float":
+                    param_values[param_name] = 0.0
+                elif param_types[param_name] == "bool":
+                    param_values[param_name] = False
+                elif param_types[param_name] == "str":
+                    param_values[param_name] = ""
+                else:
+                    param_values[param_name] = None
+
+            # Update with model values where available
+            for var_name, z3_var in z3_vars.items():
+                if var_name in param_types and z3_var in model:
+                    try:
+                        if param_types[var_name] == "int":
+                            param_values[var_name] = model[z3_var].as_long()
+                        elif param_types[var_name] == "float":
+                            param_values[var_name] = float(model[z3_var].as_decimal())
+                        elif param_types[var_name] == "bool":
+                            param_values[var_name] = z3.is_true(model[z3_var])
+                        elif param_types[var_name] == "str":
+                            param_values[var_name] = str(model[z3_var])
+                        else:
+                            param_values[var_name] = model[z3_var].as_long()
+                    except Exception as e:
+                        print(f"Error converting Z3 model value for {var_name}: {e}")
+
+            # Ensure all parameters are included in correct order
+            ordered_params = []
+            for arg in func_node.args.args:
+                arg_name = arg.arg
+                if arg_name == 'self':  # Skip self parameter for class methods
+                    continue
+                if arg_name in param_values:
+                    ordered_params.append(param_values[arg_name])
+                else:
+                    print(f"Warning: Missing value for parameter {arg_name}")
+                    # Provide default values based on annotation if available
+                    if hasattr(arg, 'annotation') and arg.annotation:
+                        if isinstance(arg.annotation, ast.Name):
+                            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)
+                    else:
+                        ordered_params.append(None)
+
+            func_name = func_node.name
+            try:
+                module = testgen.util.file_utils.load_module(file_name)
+                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 for {func_name}: {e}")
+
+    return test_cases

testgenie_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: testgenie-py
+Version: 0.1.0
+Summary: 
+Author: cjseitz
+Author-email: charlesjseitz@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: ConfigArgParse (==1.7)
+Requires-Dist: astor (==0.8.1)
+Requires-Dist: atheris (==2.3.0)
+Requires-Dist: coverage (==7.6.4)
+Requires-Dist: klara (==0.6.3)
+Requires-Dist: pytest (>=8.3.5,<9.0.0)
+Requires-Dist: staticfg (>=0.9.5,<0.10.0)
+Requires-Dist: typed-ast (==1.5.5)
+Requires-Dist: z3-solver (==4.13.3.0)
+Description-Content-Type: text/markdown
+
+

testgenie_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+testgen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/analyzer/ast_analyzer.py,sha256=JmqiosxgZJm2fhNDr5VUBpKKHmf8S2HP9Jm0Xl7NnnI,6783
+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=ktkDdh3mgHjcC4ZitGo9fa9RjnGqkdehaYJeSKssWss,4299
+testgen/analyzer/random_feedback_analyzer.py,sha256=S_8iRNmgNa2wIlhLZV798H5QWY9zwKpSs2MFE61uV60,13114
+testgen/analyzer/reinforcement_analyzer.py,sha256=U6W7g-xDFS_P0aqxjPRnaXjGp2gOC9TMdfWaetFV7eE,3568
+testgen/analyzer/test_case_analyzer.py,sha256=foHRbz9K6WAn711sXbp-smJHDjI8GTG8F2TpovLZVEo,1530
+testgen/analyzer/test_case_analyzer_context.py,sha256=7umDPHBjoTaCRvZOdNynpnWsr14Gy0E2hpMBPK8mz3Q,2128
+testgen/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/controller/cli_controller.py,sha256=dKtqQMGw1IYRQox5gmQr53KAxEtrhesUdvI0KJkMjBo,8242
+testgen/controller/docker_controller.py,sha256=fBRJFdY5NU6ipRY7Gihs-IA-EcpSa79Xu6GVh6_eaxk,6601
+testgen/docker/Dockerfile,sha256=_xr3CWP9hhBIZbf4qRzWewBUAIkXoZGAh36g3yXpAbc,513
+testgen/docker/poetry.lock,sha256=Xg2WyFgruylJ51Pvfi03Hc-VDeKj3f5DhM56XIXRBpI,30057
+testgen/docker/pyproject.toml,sha256=QToniOghAyI6Hp5V-OWknO3Mo7cpa_HCV5lqynYYuPA,438
+testgen/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/generator/code_generator.py,sha256=V5Donxz3r3ZW56xyyldJwOuDBaX6e8NOyPc8UzllQs8,2467
+testgen/generator/doctest_generator.py,sha256=Dkaf2l72ENk1mqNP3WkOnIY-iqrTHh-443AWtxzRWGY,8806
+testgen/generator/generator.py,sha256=9M9zg8DO0uU5W5s9hsz2oPCL7bz7sAD087M5TYottSs,2007
+testgen/generator/pytest_generator.py,sha256=ZjQKPHlizFK2yx9WabAxkW9sM-xa64d08IIQibnvwuk,3369
+testgen/generator/test_generator.py,sha256=D2Y3DaWH4fdIc5_9Xrznrkm0urFfhpYxuhL81M7RRaw,710
+testgen/generator/unit_test_generator.py,sha256=yXg7_A0nOR0jhOfz7yzL6C_6pwoNCwf19Bpr_RW_41I,3596
+testgen/inspector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/inspector/inspector.py,sha256=llDy03j8cz6Bk6HwSm20B8XvR5QaSxGXyNYyQxom25E,1816
+testgen/main.py,sha256=zpLLi8HtPB6p3uMTKPrsRQDREP4i-ZqrOBwroW0XekM,385
+testgen/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/models/analysis_context.py,sha256=-mhw_hn26MgF6aJnmj6Hub5jfCi8gmvcf4QNM4l7G2s,1442
+testgen/models/function_metadata.py,sha256=t2lNSycFamuec7q3fiabq6aVO5XN0bylEU7mdup7Ezc,1587
+testgen/models/generator_context.py,sha256=V-T9i-3Ar-gdBzQqidyqBb05PTmOu2LtdQdAIX3aaGk,1693
+testgen/models/test_case.py,sha256=jwodn-6fKHCh4SO2qycbrFyggCb9UlwTZ8k3RdTObDQ,216
+testgen/presentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/presentation/cli_view.py,sha256=2fZrsvZ-Wi4j37UvogsK9_yQV5o3A20jowIr6iFRu-s,296
+testgen/q_table/global_q_table.json,sha256=T1EOATQ6L9FJL8bI3HxavYBdH8l95qGC5AdiUFz2ohM,6528
+testgen/reinforcement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/reinforcement/abstract_state.py,sha256=M9Kp8fyJzsTzpyL3ca4HjjYpGXy9DRMw-IG7OgFVisY,154
+testgen/reinforcement/agent.py,sha256=wvgbi-OVoVJMwhasGgsP2y1TKLiC5qjjTwZBNqKNRns,6098
+testgen/reinforcement/environment.py,sha256=z9ENIkbiB0N9Dbhm8yruQeSV1h4sK0QDkDRF_IO1VtI,8601
+testgen/reinforcement/statement_coverage_state.py,sha256=hyoxkpOi_vdtjuAZ3PDz_fECurqWeNjeIhtng5TARCk,1523
+testgen/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/service/analysis_service.py,sha256=SvQEhwbE_lWTRrWdT70C4kbh-H2xxf0mP8zlqSX_xqI,10670
+testgen/service/cfg_service.py,sha256=7QWNM7WgX6iEwAV1qJuacKEAYihHyDqsOEMlu5Z3aA0,2207
+testgen/service/generator_service.py,sha256=iKDPyCDlektRDLD6pLrR0CWiAF81xezkFHGyT31mre8,6920
+testgen/service/service.py,sha256=WcCf8SOYAoElwFoYFpsWfZk8V675AY0pot5-QQp7AP4,15407
+testgen/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+testgen/sqlite/db.py,sha256=RUt88ndT4CQRo9aZzLGXPHRK1iw0LyDEGnoWlOLzKGM,2390
+testgen/sqlite/db_service.py,sha256=i87YkhMP0VNyug5p1tWUvnzHB8isFcSIRe9vJJTmFLA,8954
+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=lmta8F-ASsZpaAOs_YucSTHNHHEn4M0rUR7eeboZtZc,6044
+testgen/util/coverage_visualizer.py,sha256=rYmwV4uTo02YAVPy3KKlLyKofr3IuhytFBNanu0z6Ok,5668
+testgen/util/file_utils.py,sha256=P6zzABvuTlO2EAJdgFKwNxKNF_HHD0vcSkROeHrYTbg,3699
+testgen/util/randomizer.py,sha256=hAW9szYhPWyQEkn7NTFuJRRIoYcVmvnzMf3dDwWdMKM,4479
+testgen/util/utils.py,sha256=_TPXveAcI_TR9XLU8qaDx63CrZJDvpzSWl_gfYchJz0,5665
+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=cAafR5x7YMsWnqVFYU21h2jHO-SiaTDPdKe44cGQ5_M,4409
+testgenie_py-0.1.0.dist-info/METADATA,sha256=Cs5-bhHuOerWHIaHz4xK84JHOQoALkFzU8xGUes08RE,764
+testgenie_py-0.1.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+testgenie_py-0.1.0.dist-info/entry_points.txt,sha256=K52WcOoqyoG657-9IdKsDCBS_nJyuV4BhVtGzoomkL4,39
+testgenie_py-0.1.0.dist-info/RECORD,,

testgenie_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.2
+Root-Is-Purelib: true
+Tag: py3-none-any

testgenie_py-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+testgenie=main:main
+