"""

CodeAnalyzer module for analyzing code structure and relationships.

"""

import os

import ast

import re

from typing import List, Dict, Any

class CodeAnalyzer:

"""Analyzes code structure and relationships."""

@staticmethod

def map_test_to_source_files(source_files: List[str], test_files: List[str]) -> Dict[str, str]:

"""Map test files to their corresponding source files."""

mapping = {}

source_base_names = {os.path.splitext(os.path.basename(f))[0]: f for f in source_files}

for test_file in test_files:

test_name = os.path.splitext(os.path.basename(test_file))[0]

# Handle common naming patterns

if test_name.startswith('test_'):

source_name = test_name[5:] # Remove 'test_'

if source_name in source_base_names:

mapping[source_base_names[source_name]] = test_file

elif test_name.endswith('_test'):

source_name = test_name[:-5] # Remove '_test'

if source_name in source_base_names:

mapping[source_base_names[source_name]] = test_file

# If no match found by naming convention, try to infer from content

if test_file not in mapping.values():

# This would require more sophisticated analysis in a production tool

pass

return mapping

@staticmethod

def create_prompt_for_mutant(source_file: str, test_file: str, mutant: Dict[str, Any]) -> str:

"""Create a prompt for the LLM to generate a test for the given mutant."""

# Read the source file to extract the relevant function

with open(source_file, 'r', encoding='utf-8') as f:

source_content = f.read()

# Read the test file to extract existing tests

with open(test_file, 'r', encoding='utf-8') as f:

test_content = f.read()

# Parse the source file to find the function containing the mutation

tree = ast.parse(source_content)

function_name = None

function_code = None

for node in ast.walk(tree):

if isinstance(node, ast.FunctionDef):

if hasattr(node, 'lineno') and hasattr(node, 'end_lineno'):

if node.lineno <= mutant['line_number'] <= node.end_lineno:

function_name = node.name

function_code = source_content.splitlines()[node.lineno-1:node.end_lineno]

function_code = '\n'.join(function_code)

break

if not function_name or not function_code:

# If we couldn't find the function, use a more generic approach

# Extract a few lines around the mutation

lines = source_content.splitlines()

start_line = max(0, mutant['line_number'] - 5)

end_line = min(len(lines), mutant['line_number'] + 5)

context_code = '\n'.join(lines[start_line:end_line])

# Try to extract the function name from the context

match = re.search(r'def\s+(\w+)\s*\(', context_code)

if match:

function_name = match.group(1)

else:

function_name = "unknown_function"

# Extract existing tests for this function

existing_tests = ""

test_tree = ast.parse(test_content)

for node in ast.walk(test_tree):

if isinstance(node, ast.FunctionDef):

if node.name.startswith('test_') and function_name.lower() in node.name.lower():

test_code = test_content.splitlines()[node.lineno-1:node.end_lineno]

existing_tests += '\n'.join(test_code) + '\n\n'

# Create the prompt

module_name = os.path.splitext(os.path.basename(source_file))[0]

prompt = f"""

I have a function in module '{module_name}':

{function_code}

My current test(s) for this function:

{existing_tests}

I found a bug where changing '{mutant['original_line']}' to '{mutant['mutated_line']}' at line {mutant['line_number']} isn't caught by my test suite.

Please generate a new test method that would detect this change. The test should pass on the original code but fail if the mutation is applied.

Return only the Python code for the test method, properly indented and with docstrings explaining what it tests.

"""

return prompt