adversarial-analysis

Adversarial Code Analysis

Purpose

Map the "Surface of Reality" for target code. Your goal is to distinguish:

• Contract Violations (invalid inputs the caller shouldn't send) → NOT testable
• Logic Bugs (valid inputs the code handles poorly) → TESTABLE

Analysis Checklist

1. Contract Extraction

Explicit Contracts:

• Type hints (int, str, Optional[T], List[T])
• assert statements and preconditions
• Docstring Args, Raises, Returns sections
• Validation code at function entry

Implicit Contracts:

• Variable names implying limits (retry_count → small positive int, buffer_size → memory-reasonable)
• Context from call sites (what values are actually passed?)
• Domain knowledge (user IDs are positive, emails contain @)

External Constraints:

• Database column limits (VARCHAR(255))
• API rate limits and timeouts
• Filesystem permissions and path length limits

2. Realism Baseline (The 3-Sigma Rule)

Use Grep to scan existing tests in tests/ and call sites in src/. Calculate boundaries:

String Inputs:

existing_lengths = [len(s) for each test string argument]
if len(existing_lengths) >= 5:
    Max_Realistic_Length = mean(existing_lengths) + 3 * std(existing_lengths)
elif len(existing_lengths) >= 1:
    Max_Realistic_Length = max(existing_lengths) * 2
else:
    Max_Realistic_Length = 256  # Zero-sample fallback

Numeric Inputs:

existing_values = [v for each numeric argument]
if len(existing_values) >= 5:
    Lower = mean(existing_values) - 3 * std(existing_values)
    Upper = mean(existing_values) + 3 * std(existing_values)
elif len(existing_values) >= 1:
    Lower = min(existing_values) - abs(min(existing_values))
    Upper = max(existing_values) + abs(max(existing_values))
else:
    Lower, Upper = -1000, 1000  # Zero-sample fallback

Special Boundaries (Always Valid):

• 0, -1, 1 for integers (if type allows)
• Empty string "" (if not explicitly forbidden)
• None only if type is Optional