src/generator.py - master - Armen_B/test-case-generator

src/generator.py
289 строк8 KB
Armen_B
update src/generator.py
27 дек 2025, 20:57
27 дек 2025, 20:57ea0144d
"""
Generator module for creating test cases for programming problems.
"""
import random
import json
from typing import List, Dict, Any


def generate_sorting_tests(count: int = 5) -> List[Dict[str, Any]]:
    """
    Generate test cases for sorting algorithms.
    
    Args:
        count: Number of random tests to generate (edge cases are added automatically)
    
    Returns:
        List of test cases
    """
    tests = []
    
    # Generate random tests
    for i in range(count):
        size = random.randint(3, 10)
        arr = [random.randint(-100, 100) for _ in range(size)]
        tests.append({
            "input": arr,
            "expected": sorted(arr),
            "description": f"Random array #{i+1} (size={size})",
            "type": "sorting"
        })
    
    # Add standard edge cases
    edge_cases = [
        ([], [], "Empty array"),
        ([1], [1], "Single element"),
        ([1, 1, 1], [1, 1, 1], "All same elements"),
        ([5, 4, 3, 2, 1], [1, 2, 3, 4, 5], "Reverse sorted"),
        ([-5, -1, -3], [-5, -3, -1], "All negative numbers"),
        ([-5, 0, 5], [-5, 0, 5], "Mixed negative/positive/zero"),
    ]
    
    for inp, exp, desc in edge_cases:
        tests.append({
            "input": inp,
            "expected": exp,
            "description": f"Edge case: {desc}",
            "type": "sorting",
            "is_edge_case": True
        })
    
    # Add large numbers edge cases
    large_number_cases = [
        ([10**9, 10**9 + 1, 10**9 - 1], 
         [10**9 - 1, 10**9, 10**9 + 1],
         "Very large numbers (10^9 range)"),
        ([-10**9, 10**9, 0],
         [-10**9, 0, 10**9],
         "Mixed large positive/negative"),
        ([2**31 - 1, -2**31, 0],
         [-2**31, 0, 2**31 - 1],
         "32-bit integer boundaries"),
    ]
    
    for inp, exp, desc in large_number_cases:
        tests.append({
            "input": inp,
            "expected": exp,
            "description": f"Edge case: {desc}",
            "type": "sorting",
            "is_edge_case": True
        })
    
    return tests


def generate_search_tests(count: int = 5) -> List[Dict[str, Any]]:
    """
    Generate test cases for binary search.
    
    Args:
        count: Number of tests to generate
    
    Returns:
        List of test cases
    """
    tests = []
    
    for i in range(count):
        # Generate sorted array
        size = random.randint(5, 15)
        arr = sorted(random.sample(range(100), size))
        
        # 70% chance target exists in array
        if random.random() < 0.7:
            target = random.choice(arr)
            expected = arr.index(target)
        else:
            # Target doesn't exist
            target = random.randint(150, 200)
            expected = -1
        
        tests.append({
            "input": {"array": arr, "target": target},
            "expected": expected,
            "description": f"Binary search test #{i+1}",
            "type": "searching"
        })
    
    # Edge cases for searching
    search_edge_cases = [
        ({"array": [], "target": 5}, -1, "Empty array"),
        ({"array": [1], "target": 1}, 0, "Single element found"),
        ({"array": [1], "target": 2}, -1, "Single element not found"),
        ({"array": [1, 1, 1], "target": 1}, 0, "All same elements (first occurrence)"),
        ({"array": list(range(1000)), "target": 999}, 999, "Large array (1000 elements)"),
    ]
    
    for inp, exp, desc in search_edge_cases:
        tests.append({
            "input": inp,
            "expected": exp,
            "description": f"Edge case: {desc}",
            "type": "searching",
            "is_edge_case": True
        })
    
    return tests


def generate_linked_list_tests(count: int = 5) -> List[Dict[str, Any]]:
    """
    Generate test cases for linked list operations.
    
    Args:
        count: Number of tests to generate
    
    Returns:
        List of test cases
    """
    tests = []
    
    operations = ["reverse", "middle", "has_cycle", "nth_from_end"]
    
    for i in range(count):
        size = random.randint(3, 10)
        values = [random.randint(1, 100) for _ in range(size)]
        
        # Different expected outputs based on operation
        operation = random.choice(operations)
        
        if operation == "reverse":
            expected = list(reversed(values))
        elif operation == "middle":
            expected = values[size // 2]
        elif operation == "has_cycle":
            expected = False  # Simple case, no cycle
        elif operation == "nth_from_end":
            n = random.randint(1, min(3, size))
            expected = values[-n]
        
        tests.append({
            "input": {"values": values, "operation": operation},
            "expected": expected,
            "description": f"Linked list {operation} test #{i+1}",
            "type": "linked_list"
        })
    
    # Edge cases for linked lists
    ll_edge_cases = [
        ({"values": [], "operation": "reverse"}, [], "Empty list"),
        ({"values": [1], "operation": "reverse"}, [1], "Single element list"),
        ({"values": list(range(100)), "operation": "middle"}, 49, "Large list (100 elements)"),
    ]
    
    for inp, exp, desc in ll_edge_cases:
        tests.append({
            "input": inp,
            "expected": exp,
            "description": f"Edge case: {desc}",
            "type": "linked_list",
            "is_edge_case": True
        })
    
    return tests


def generate_stack_tests(count: int = 5) -> List[Dict[str, Any]]:
    """
    Generate test cases for stack operations.
    
    Args:
        count: Number of tests to generate
    
    Returns:
        List of test cases
    """
    tests = []
    
    for i in range(count):
        operations = []
        stack = []
        expected = []
        
        # Generate random sequence of push/pop operations
        num_ops = random.randint(3, 8)
        for _ in range(num_ops):
            if random.random() < 0.6 or not stack:  # 60% push or if empty
                val = random.randint(1, 100)
                operations.append(("push", val))
                stack.append(val)
                expected.append(None)
            else:
                operations.append(("pop", None))
                expected.append(stack.pop())
        
        tests.append({
            "input": {"operations": operations},
            "expected": expected,
            "description": f"Stack operations test #{i+1}",
            "type": "stack"
        })
    
    return tests


def export_to_json(tests: List[Dict[str, Any]], filename: str):
    """
    Export tests to JSON file.
    
    Args:
        tests: List of test cases
        filename: Output file name
    """
    result = {
        "metadata": {
            "generated_at": "2025-12-17T12:00:00Z",  # Will be replaced in actual use
            "total_tests": len(tests),
            "test_types": list(set(t["type"] for t in tests))
        },
        "tests": tests
    }
    
    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(result, f, indent=2, ensure_ascii=False)
    print(f"✅ Exported {len(tests)} tests to {filename}")


def generate_all_tests(count_per_type: int = 3) -> Dict[str, List[Dict[str, Any]]]:
    """
    Generate test cases for all problem types.
    
    Args:
        count_per_type: Number of tests to generate per type
    
    Returns:
        Dictionary with tests by type
    """
    return {
        "sorting": generate_sorting_tests(count_per_type),
        "searching": generate_search_tests(count_per_type),
        "linked_list": generate_linked_list_tests(count_per_type),
        "stack": generate_stack_tests(count_per_type)
    }


if __name__ == "__main__":
    # Demo when run directly
    print("🧪 Test Case Generator Demo")
    print("=" * 40)
    
    print("\n📊 Generating sample tests...")
    
    all_tests = generate_all_tests(2)
    
    for test_type, tests in all_tests.items():
        print(f"\n{test_type.upper()} tests ({len(tests)} total):")
        for i, test in enumerate(tests[:2], 1):  # Show first 2
            is_edge = " (EDGE)" if test.get("is_edge_case") else ""
            print(f"  {i}. {test['description']}{is_edge}")
    
    print(f"\n✅ Generated {sum(len(t) for t in all_tests.values())} total test cases")
    
    # Export sample
    all_tests_list = []
    for tests in all_tests.values():
        all_tests_list.extend(tests)
    
    export_to_json(all_tests_list, "sample_tests.json")
    print("📁 Sample tests exported to: sample_tests.json")